Disable COM Initialization on SchedulerWorkers When COM_INIT_CHECK_HOOK_ENABLED()

base/task_scheduler/scheduler_worker.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/task_scheduler/scheduler_worker.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/task_scheduler/task_tracker.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/scoped_nsautorelease_pool.h"
 #elif defined(OS_WIN)
+#include "base/win/com_init_check_hook.h"
 #include "base/win/scoped_com_initializer.h"
 #endif
 
 namespace base {
 namespace internal {
 
 class SchedulerWorker::Thread : public PlatformThread::Delegate {
  public:
   ~Thread() override = default;
 
   static std::unique_ptr<Thread> Create(scoped_refptr<SchedulerWorker> outer) {
     std::unique_ptr<Thread> thread(new Thread(std::move(outer)));
     thread->Initialize();
     if (thread->thread_handle_.is_null())
       return nullptr;
     return thread;
   }
 
   // PlatformThread::Delegate.
   void ThreadMain() override {
     // Set if this thread was detached.
     std::unique_ptr<Thread> detached_thread;
 
     outer_->delegate_->OnMainEntry(outer_.get());
 
     // A SchedulerWorker starts out waiting for work.
     outer_->delegate_->WaitForWork(&wake_up_event_);
 
-#if defined(OS_WIN)
+    // When defined(COM_INIT_CHECK_HOOK_ENABLED), ignore
+    // SchedulerBackwardCompatibility::INIT_COM_STA to find incorrect uses of
+    // COM that should be running in a COM STA Task Runner.
+#if defined(OS_WIN) && !defined(COM_INIT_CHECK_HOOK_ENABLED)
     std::unique_ptr<win::ScopedCOMInitializer> com_initializer;
     if (outer_->backward_compatibility_ ==
         SchedulerBackwardCompatibility::INIT_COM_STA) {
       com_initializer = MakeUnique<win::ScopedCOMInitializer>();
     }
 #endif
 
     while (!outer_->ShouldExit()) {
       DCHECK(outer_);
 
@@ skipping 146 matching lines @@
     ThreadPriority priority_hint,
     std::unique_ptr<Delegate> delegate,
     TaskTracker* task_tracker,
     const SchedulerLock* predecessor_lock,
     SchedulerBackwardCompatibility backward_compatibility,
     InitialState initial_state)
     : thread_lock_(predecessor_lock),
       priority_hint_(priority_hint),
       delegate_(std::move(delegate)),
       task_tracker_(task_tracker),
-#if defined(OS_WIN)
+#if defined(OS_WIN) && !defined(COM_INIT_CHECK_HOOK_ENABLED)
       backward_compatibility_(backward_compatibility),
 #endif
       initial_state_(initial_state) {
   DCHECK(delegate_);
   DCHECK(task_tracker_);
 }
 
 bool SchedulerWorker::Start() {
   AutoSchedulerLock auto_lock(thread_lock_);
   DCHECK(!started_);
@@ skipping 104 matching lines @@
   // The ordering of the checks is important below. This SchedulerWorker may be
   // released and outlive |task_tracker_| in unit tests. However, when the
   // SchedulerWorker is released, |should_exit_| will be set, so check that
   // first.
   return should_exit_.IsSet() || join_called_for_testing_.IsSet() ||
          task_tracker_->IsShutdownComplete();
 }
 
 }  // namespace internal
 }  // namespace base