Allow Thread to initialize COM for Windows consumers who need it

base/threading/thread.h

 // Copyright (c) 2012 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.
 
-#ifndef BASE_THREAD_H_
-#define BASE_THREAD_H_
+#ifndef BASE_THREADING_THREAD_H_
+#define BASE_THREADING_THREAD_H_
 
 #include <string>
 
 #include "base/base_export.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/threading/platform_thread.h"
 
+#if defined(OS_WIN)
+#include "base/memory/scoped_ptr.h"
+#endif
+
 namespace base {
 
+#if defined(OS_WIN)
+namespace win {
+class ScopedCOMInitializer;
+}
+#endif
+
 // A simple thread abstraction that establishes a MessageLoop on a new thread.
 // The consumer uses the MessageLoop of the thread to cause code to execute on
 // the thread.  When this object is destroyed the thread is terminated.  All
 // pending tasks queued on the thread's message loop will run to completion
 // before the thread is terminated.
 //
 // WARNING! SUBCLASSES MUST CALL Stop() IN THEIR DESTRUCTORS!  See ~Thread().
 //
 // After the thread is stopped, the destruction sequence is:
 //
@@ skipping 23 matching lines @@
   // Destroys the thread, stopping it if necessary.
   //
   // NOTE: ALL SUBCLASSES OF Thread MUST CALL Stop() IN THEIR DESTRUCTORS (or
   // guarantee Stop() is explicitly called before the subclass is destroyed).
   // This is required to avoid a data race between the destructor modifying the
   // vtable, and the thread's ThreadMain calling the virtual method Run().  It
   // also ensures that the CleanUp() virtual method is called on the subclass
   // before it is destructed.
   virtual ~Thread();
 
+#if defined(OS_WIN)
+  // Causes the thread to initialize COM.  This must be called before calling
+  // Start() or StartWithOptions().  If |use_mta| is false, the thread is also
+  // started with a TYPE_UI message loop.  It is an error to call
+  // init_com_with_mta(false) and then StartWithOptions() with any message loop
+  // type other than TYPE_UI.
+  void init_com_with_mta(bool use_mta) {
+    DCHECK(!started_);
+    com_status_ = use_mta ? MTA : STA;
+  }
+#endif
+
   // Starts the thread.  Returns true if the thread was successfully started;
   // otherwise, returns false.  Upon successful return, the message_loop()
   // getter will return non-null.
   //
   // Note: This function can't be called on Windows with the loader lock held;
   // i.e. during a DllMain, global object construction or destruction, atexit()
   // callback.
   bool Start();
 
   // Starts the thread. Behaves exactly like Start in addition to allow to
@@ skipping 71 matching lines @@
   virtual void CleanUp() {}
 
   static void SetThreadWasQuitProperly(bool flag);
   static bool GetThreadWasQuitProperly();
 
   void set_message_loop(MessageLoop* message_loop) {
     message_loop_ = message_loop;
   }
 
  private:
-  bool thread_was_started() const { return started_; }
+#if defined(OS_WIN)
+  enum ComStatus {
+    NONE,
+    STA,
+    MTA,
+  };
+  ComStatus com_status_;
+  scoped_ptr<win::ScopedCOMInitializer> com_initializer_;
+#endif
 
   // PlatformThread::Delegate methods:
   virtual void ThreadMain() OVERRIDE;
 
   // Whether we successfully started the thread.
   bool started_;
 
   // If true, we're in the middle of stopping, and shouldn't access
   // |message_loop_|. It may non-NULL and invalid.
   bool stopping_;
@@ skipping 18 matching lines @@
   // The name of the thread.  Used for debugging purposes.
   std::string name_;
 
   friend void ThreadQuitHelper();
 
   DISALLOW_COPY_AND_ASSIGN(Thread);
 };
 
 }  // namespace base
 
-#endif  // BASE_THREAD_H_
+#endif  // BASE_THREADING_THREAD_H_