Allow Thread to initialize COM for Windows consumers who need it

remoting/host/setup/daemon_controller_win.cc

 // 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.
 
 #include "remoting/host/setup/daemon_controller.h"
 
 #include <objbase.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/string16.h"
 #include "base/threading/thread.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/win/scoped_bstr.h"
-#include "base/win/scoped_com_initializer.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/windows_version.h"
 #include "remoting/base/scoped_sc_handle_win.h"
 #include "remoting/host/branding.h"
 #include "remoting/host/setup/daemon_installer_win.h"
 #include "remoting/host/usage_stats_consent.h"
 
 // MIDL-generated declarations and definitions.
 #include "remoting/host/elevated_controller.h"
 
@@ skipping 21 matching lines @@
 // sees.
 const int kPrivilegedTimeoutSec = 5 * 60;
 
 // The maximum duration of keeping a reference to an unprivileged instance of
 // the Daemon Controller. This interval should not be too long. If upgrade
 // happens while there is a live reference to a Daemon Controller instance
 // the old binary still can be used. So dropping the references often makes sure
 // that the old binary will go away sooner.
 const int kUnprivilegedTimeoutSec = 60;
 
-// A base::Thread implementation that initializes COM on the new thread.
-class ComThread : public base::Thread {
- public:
-  explicit ComThread(const char* name);
-  virtual ~ComThread();
-
-  bool Start();
-
- private:
-  virtual void Init() OVERRIDE;
-  virtual void CleanUp() OVERRIDE;
-
-  scoped_ptr<base::win::ScopedCOMInitializer> com_initializer_;
-
-  DISALLOW_COPY_AND_ASSIGN(ComThread);
-};
-
 class DaemonControllerWin : public remoting::DaemonController {
  public:
   DaemonControllerWin();
   virtual ~DaemonControllerWin();
 
   virtual State GetState() OVERRIDE;
   virtual void GetConfig(const GetConfigCallback& callback) OVERRIDE;
   virtual void SetConfigAndStart(
       scoped_ptr<base::DictionaryValue> config,
       bool consent,
@@ skipping 64 matching lines @@
   // controller.
   bool control_is_elevated_;
 
   // This timer is used to release |control_| after a timeout.
   scoped_ptr<base::OneShotTimer<DaemonControllerWin> > release_timer_;
 
   // Handle of the plugin window.
   HWND window_handle_;
 
   // The worker thread used for servicing long running operations.
-  ComThread worker_thread_;
+  base::Thread worker_thread_;
 
   scoped_ptr<DaemonInstallerWin> installer_;
 
   DISALLOW_COPY_AND_ASSIGN(DaemonControllerWin);
 };
 
-ComThread::ComThread(const char* name) : base::Thread(name) {
-}
-
-ComThread::~ComThread() {
-  Stop();
-}
-
-bool ComThread::Start() {
-  // N.B. The single threaded COM apartment must be run on a UI message loop.
-  base::Thread::Options thread_options(MessageLoop::TYPE_UI, 0);
-  return StartWithOptions(thread_options);
-}
-
-void ComThread::Init() {
-  com_initializer_.reset(new base::win::ScopedCOMInitializer());
-}
-
-void ComThread::CleanUp() {
-  com_initializer_.reset();
-}
-
 DaemonControllerWin::DaemonControllerWin()
     : control_is_elevated_(false),
       window_handle_(NULL),
       worker_thread_(kDaemonControllerThreadName) {
+  worker_thread_.init_com_with_mta(false);
   if (!worker_thread_.Start()) {
     LOG(FATAL) << "Failed to start the Daemon Controller worker thread.";
   }
 }
 
 DaemonControllerWin::~DaemonControllerWin() {
   // Clean up resources allocated on the worker thread.
   worker_thread_.message_loop_proxy()->PostTask(
       FROM_HERE,
       base::Bind(&DaemonControllerWin::ReleaseController,
@@ skipping 493 matching lines @@
   done.Run(true, !!allowed, !!set_by_policy);
 }
 
 }  // namespace
 
 scoped_ptr<DaemonController> remoting::DaemonController::Create() {
   return scoped_ptr<DaemonController>(new DaemonControllerWin());
 }
 
 }  // namespace remoting