ThreadPool: PlatformNativeWorkerPoolWin should use CallbackMayRunLong for blocking tasks

The Windows Thread Pool API provides a CallbackMayRunLong method to
indicate that a callback may not return quickly. The thread pool can use
this information to better determine when a new thread should be
created.

This CL teaches PlatformNativeWorkerPoolWin about ScopedBlockingCall in
order to determine whether a callback will return quickly. A
BlockingObserver is registered before running a task in the work
callback. If the task contains a ScopedBlockingCall, the observer is
notified, and will call CallbackMayRunLong on the appropriate
PTP_CALLBACK_INSTANCE.

Bug: 756547
Change-Id: If04d2c5e01b00960dc510e94ff89525036c2ae67
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1574229
Commit-Queue: François Doray <fdoray@chromium.org>
Reviewed-by: François Doray <fdoray@chromium.org>
Cr-Commit-Position: refs/heads/master@{#653252}

base/task/thread_pool/platform_native_worker_pool_win.cc

@@ -6,11 +6,38 @@
 
 #include "base/optional.h"
 #include "base/task/thread_pool/task_tracker.h"
+#include "base/threading/scoped_blocking_call.h"
 #include "base/win/scoped_com_initializer.h"
 
 namespace base {
 namespace internal {
 
+class PlatformNativeWorkerPoolWin::ScopedCallbackMayRunLongObserver
+    : public BlockingObserver {
+ public:
+  ScopedCallbackMayRunLongObserver(PTP_CALLBACK_INSTANCE callback)
+      : callback_(callback) {
+    SetBlockingObserverForCurrentThread(this);
+  }
+
+  ~ScopedCallbackMayRunLongObserver() override {
+    ClearBlockingObserverForCurrentThread();
+  }
+
+  // BlockingObserver:
+  void BlockingStarted(BlockingType blocking_type) override {
+    ::CallbackMayRunLong(callback_);
+  }
+
+  void BlockingTypeUpgraded() override {}
+  void BlockingEnded() override {}
+
+ private:
+  PTP_CALLBACK_INSTANCE callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(ScopedCallbackMayRunLongObserver);
+};
+
 PlatformNativeWorkerPoolWin::PlatformNativeWorkerPoolWin(
     TrackedRef<TaskTracker> task_tracker,
     TrackedRef<Delegate> delegate,
@@ -44,13 +71,13 @@ void PlatformNativeWorkerPoolWin::JoinImpl() {
 
 void PlatformNativeWorkerPoolWin::SubmitWork() {
   // TODO(fdoray): Handle priorities by having different work objects and using
-  // SetThreadpoolCallbackPriority() and SetThreadpoolCallbackRunsLong().
+  // SetThreadpoolCallbackPriority().
   ::SubmitThreadpoolWork(work_);
 }
 
 // static
 void CALLBACK PlatformNativeWorkerPoolWin::RunNextSequence(
-    PTP_CALLBACK_INSTANCE,
+    PTP_CALLBACK_INSTANCE callback_instance,
     void* scheduler_worker_pool_windows_impl,
     PTP_WORK) {
   auto* worker_pool = static_cast<PlatformNativeWorkerPoolWin*>(
@@ -63,6 +90,9 @@ void CALLBACK PlatformNativeWorkerPoolWin::RunNextSequence(
   if (worker_pool->worker_environment_ == WorkerEnvironment::COM_MTA)
     com_initializer.emplace(win::ScopedCOMInitializer::kMTA);
 
+  ScopedCallbackMayRunLongObserver callback_may_run_long_observer(
+      callback_instance);
+
   worker_pool->RunNextSequenceImpl();
 }
 

base/task/thread_pool/platform_native_worker_pool_win.h

@@ -34,8 +34,10 @@ class BASE_EXPORT PlatformNativeWorkerPoolWin
   ~PlatformNativeWorkerPoolWin() override;
 
  private:
+  class ScopedCallbackMayRunLongObserver;
+
   // Callback that gets run by |pool_|.
-  static void CALLBACK RunNextSequence(PTP_CALLBACK_INSTANCE,
+  static void CALLBACK RunNextSequence(PTP_CALLBACK_INSTANCE callback_instance,
                                        void* scheduler_worker_pool_windows_impl,
                                        PTP_WORK);
 

base/threading/scoped_blocking_call.cc

@@ -121,7 +121,7 @@ void SetBlockingObserverForCurrentThread(BlockingObserver* blocking_observer) {
   tls_blocking_observer.Get().Set(blocking_observer);
 }
 
-void ClearBlockingObserverForTesting() {
+void ClearBlockingObserverForCurrentThread() {
   tls_blocking_observer.Get().Set(nullptr);
 }
 

base/threading/scoped_blocking_call.h

@@ -160,7 +160,7 @@ class BASE_EXPORT BlockingObserver {
 BASE_EXPORT void SetBlockingObserverForCurrentThread(
     BlockingObserver* blocking_observer);
 
-BASE_EXPORT void ClearBlockingObserverForTesting();
+BASE_EXPORT void ClearBlockingObserverForCurrentThread();
 
 // Unregisters the |blocking_observer| on the current thread within its scope.
 // Used in ThreadPool tests to prevent calls to //base sync primitives from

base/threading/scoped_blocking_call_unittest.cc

@@ -34,7 +34,7 @@ class ScopedBlockingCallTest : public testing::Test {
   }
 
   ~ScopedBlockingCallTest() override {
-    internal::ClearBlockingObserverForTesting();
+    internal::ClearBlockingObserverForCurrentThread();
   }
 
   testing::StrictMock<MockBlockingObserver> observer_;