Clean up EGL thread state at thread exit in nanobench and DM

src/core/SkTaskGroup.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkOnce.h"
 #include "SkSemaphore.h"
 #include "SkSpinlock.h"
@@ skipping 78 matching lines @@
         ~AutoLock() { fLock->release(); }
     private:
         SkSpinlock* fLock;
     };
 
     struct Work {
         std::function<void(void)> fn; // A function to call
         SkAtomic<int32_t>* pending;   // then decrement pending afterwards.
     };
 
-    explicit ThreadPool(int threads) {
+    explicit ThreadPool(int threads, std::function<void(void)> cleanupFn)
+        : fCleanupFn(cleanupFn) {
         if (threads == -1) {
             threads = sk_num_cores();
         }
         for (int i = 0; i < threads; i++) {
             fThreads.push(new SkThread(&ThreadPool::Loop, this));
             fThreads.top()->start();
         }
     }
 
     ~ThreadPool() {
@@ skipping 44 matching lines @@
                 AutoLock lock(&pool->fWorkLock);
                 if (pool->fWork.empty()) {
                     // Someone in Wait() stole our work (fWorkAvailable is an upper bound).
                     // Well, that's fine, back to sleep for us.
                     continue;
                 }
                 work = pool->fWork.back();
                 pool->fWork.pop_back();
             }
             if (!work.fn) {
+                if (pool->fCleanupFn) {
+                    pool->fCleanupFn();
+                }
                 return;  // Poison pill.  Time... to die.
             }
             work.fn();
             work.pending->fetch_add(-1, sk_memory_order_release);  // Pairs with load in Wait().
         }
     }
 
     // fWorkLock must be held when reading or modifying fWork.
     SkSpinlock      fWorkLock;
     SkTArray<Work>  fWork;
 
     // A thread-safe upper bound for fWork.count().
     //
     // We'd have it be an exact count but for the loop in Wait():
     // we never want that to block, so it can't call fWorkAvailable.wait(),
     // and that's the only way to decrement fWorkAvailable.
     // So fWorkAvailable may overcount actual the work available.
     // We make do, but this means some worker threads may wake spuriously.
     SkSemaphore fWorkAvailable;
 
     // These are only changed in a single-threaded context.
     SkTDArray<SkThread*> fThreads;
+
+    std::function<void(void)> fCleanupFn;
     static ThreadPool* gGlobal;
 
     friend struct SkTaskGroup::Enabler;
 };
 ThreadPool* ThreadPool::gGlobal = nullptr;
 
 }  // namespace
 
-SkTaskGroup::Enabler::Enabler(int threads) {
+SkTaskGroup::Enabler::Enabler(int threads, std::function<void(void)> cleanupFn)
+    : fCleanupFn(cleanupFn) {
     SkASSERT(ThreadPool::gGlobal == nullptr);
     if (threads != 0) {
-        ThreadPool::gGlobal = new ThreadPool(threads);
+        ThreadPool::gGlobal = new ThreadPool(threads, cleanupFn);
     }
 }
 
-SkTaskGroup::Enabler::~Enabler() { delete ThreadPool::gGlobal; }
+SkTaskGroup::Enabler::~Enabler() {
+    if (!ThreadPool::gGlobal && fCleanupFn) {
+        fCleanupFn();
+    }
+    delete ThreadPool::gGlobal;
+}
 
 SkTaskGroup::SkTaskGroup() : fPending(0) {}
 
 void SkTaskGroup::wait()                            { ThreadPool::Wait(&fPending); }
 void SkTaskGroup::add(std::function<void(void)> fn) { ThreadPool::Add(fn, &fPending); }
 void SkTaskGroup::batch(int N, std::function<void(int)> fn) {
     ThreadPool::Batch(N, fn, &fPending);
 }