remoting/base/auto_thread.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "remoting/base/auto_thread.h"
   6
   7 #include "base/bind.h"
   8 #include "base/lazy_instance.h"
   9 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
  10 #include "base/threading/thread_local.h"
  11 #include "base/threading/thread_restrictions.h"
  12 #include "base/synchronization/waitable_event.h"
  13 #include "remoting/base/auto_thread_task_runner.h"
  14
  15 #if defined(OS_WIN)
  16 #include "base/win/scoped_com_initializer.h"
  17 #endif
  18
  19 namespace remoting {
  20
  21 namespace {
  22
  23 #if defined(OS_WIN)
  24 scoped_ptr<base::win::ScopedCOMInitializer> CreateComInitializer(
  25     AutoThread::ComInitType type) {
  26   scoped_ptr<base::win::ScopedCOMInitializer> initializer;
  27   if (type == AutoThread::COM_INIT_MTA) {
  28     initializer.reset(new base::win::ScopedCOMInitializer(
  29         base::win::ScopedCOMInitializer::kMTA));
  30   } else if (type == AutoThread::COM_INIT_STA) {
  31     initializer.reset(new base::win::ScopedCOMInitializer());
  32   }
  33   return initializer.Pass();
  34 }
  35 #endif
  36
  37 }
  38
  39 // Used to pass data to ThreadMain.  This structure is allocated on the stack
  40 // from within StartWithType.
  41 struct AutoThread::StartupData {
  42   // Fields describing the desired thread behaviour.
  43   base::MessageLoop::Type loop_type;
  44
  45   // Used to receive the AutoThreadTaskRunner for the thread.
  46   scoped_refptr<AutoThreadTaskRunner> task_runner;
  47
  48   // Used to synchronize thread startup.
  49   base::WaitableEvent event;
  50
  51   explicit StartupData(base::MessageLoop::Type type)
  52       : loop_type(type), event(false, false) {}
  53 };
  54
  55 // static
  56 scoped_refptr<AutoThreadTaskRunner> AutoThread::CreateWithType(
  57     const char* name,
  58     scoped_refptr<AutoThreadTaskRunner> joiner,
  59     base::MessageLoop::Type type) {
  60   AutoThread* thread = new AutoThread(name, joiner.get());
  61   scoped_refptr<AutoThreadTaskRunner> task_runner = thread->StartWithType(type);
  62   if (!task_runner.get())
  63     delete thread;
  64   return task_runner;
  65 }
  66
  67 // static
  68 scoped_refptr<AutoThreadTaskRunner> AutoThread::Create(
  69     const char* name, scoped_refptr<AutoThreadTaskRunner> joiner) {
  70   return CreateWithType(name, joiner, base::MessageLoop::TYPE_DEFAULT);
  71 }
  72
  73 #if defined(OS_WIN)
  74 // static
  75 scoped_refptr<AutoThreadTaskRunner> AutoThread::CreateWithLoopAndComInitTypes(
  76     const char* name,
  77     scoped_refptr<AutoThreadTaskRunner> joiner,
  78     base::MessageLoop::Type loop_type,
  79     ComInitType com_init_type) {
  80   AutoThread* thread = new AutoThread(name, joiner.get());
  81   thread->SetComInitType(com_init_type);
  82   scoped_refptr<AutoThreadTaskRunner> task_runner =
  83       thread->StartWithType(loop_type);
  84   if (!task_runner.get())
  85     delete thread;
  86   return task_runner;
  87 }
  88 #endif
  89
  90 AutoThread::AutoThread(const char* name)
  91   : startup_data_(NULL),
  92 #if defined(OS_WIN)
  93     com_init_type_(COM_INIT_NONE),
  94 #endif
  95     thread_(),
  96     name_(name),
  97     was_quit_properly_(false) {
  98 }
  99
 100 AutoThread::AutoThread(const char* name, AutoThreadTaskRunner* joiner)
 101   : startup_data_(NULL),
 102 #if defined(OS_WIN)
 103     com_init_type_(COM_INIT_NONE),
 104 #endif
 105     thread_(),
 106     name_(name),
 107     was_quit_properly_(false),
 108     joiner_(joiner) {
 109 }
 110
 111 AutoThread::~AutoThread() {
 112   DCHECK(!startup_data_);
 113
 114   // Wait for the thread to exit.
 115   if (!thread_.is_null()) {
 116     base::PlatformThread::Join(thread_);
 117   }
 118 }
 119
 120 scoped_refptr<AutoThreadTaskRunner> AutoThread::StartWithType(
 121     base::MessageLoop::Type type) {
 122   DCHECK(thread_.is_null());
 123 #if defined(OS_WIN)
 124   DCHECK(com_init_type_ != COM_INIT_STA || type == base::MessageLoop::TYPE_UI);
 125 #endif
 126
 127   StartupData startup_data(type);
 128   startup_data_ = &startup_data;
 129
 130   if (!base::PlatformThread::Create(0, this, &thread_)) {
 131     DLOG(ERROR) << "failed to create thread";
 132     startup_data_ = NULL;
 133     return NULL;
 134   }
 135
 136   // Wait for the thread to start and initialize message_loop_
 137   // TODO(wez): Since at this point we know the MessageLoop _will_ run, and
 138   // the thread lifetime is controlled by the AutoThreadTaskRunner, we would
 139   // ideally return the AutoThreadTaskRunner to the caller without waiting for
 140   // the thread to signal us.
 141   base::ThreadRestrictions::ScopedAllowWait allow_wait;
 142   startup_data.event.Wait();
 143
 144   // set it to NULL so we don't keep a pointer to some object on the stack.
 145   startup_data_ = NULL;
 146
 147   DCHECK(startup_data.task_runner.get());
 148   return startup_data.task_runner;
 149 }
 150
 151 #if defined(OS_WIN)
 152 void AutoThread::SetComInitType(ComInitType com_init_type) {
 153   DCHECK_EQ(com_init_type_, COM_INIT_NONE);
 154   com_init_type_ = com_init_type;
 155 }
 156 #endif
 157
 158 void AutoThread::QuitThread(
 159     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
 160   if (!task_runner->BelongsToCurrentThread()) {
 161     task_runner->PostTask(FROM_HERE, base::Bind(&AutoThread::QuitThread,
 162                                                 base::Unretained(this),
 163                                                 task_runner));
 164     return;
 165   }
 166
 167   base::MessageLoop::current()->Quit();
 168   was_quit_properly_ = true;
 169
 170   if (joiner_.get()) {
 171     joiner_->PostTask(
 172         FROM_HERE,
 173         base::Bind(&AutoThread::JoinAndDeleteThread, base::Unretained(this)));
 174   }
 175 }
 176
 177 void AutoThread::JoinAndDeleteThread() {
 178   delete this;
 179 }
 180
 181 void AutoThread::ThreadMain() {
 182   // The message loop for this thread.
 183   base::MessageLoop message_loop(startup_data_->loop_type);
 184
 185   // Complete the initialization of our AutoThread object.
 186   base::PlatformThread::SetName(name_);
 187   ANNOTATE_THREAD_NAME(name_.c_str());  // Tell the name to race detector.
 188   message_loop.set_thread_name(name_);
 189
 190   // Return an AutoThreadTaskRunner that will cleanly quit this thread when
 191   // no more references to it remain.
 192   startup_data_->task_runner =
 193       new AutoThreadTaskRunner(message_loop.message_loop_proxy(),
 194           base::Bind(&AutoThread::QuitThread,
 195                      base::Unretained(this),
 196                      message_loop.message_loop_proxy()));
 197
 198   startup_data_->event.Signal();
 199   // startup_data_ can't be touched anymore since the starting thread is now
 200   // unlocked.
 201
 202 #if defined(OS_WIN)
 203   // Initialize COM on the thread, if requested.
 204   scoped_ptr<base::win::ScopedCOMInitializer> com_initializer(
 205       CreateComInitializer(com_init_type_));
 206 #endif
 207
 208   message_loop.Run();
 209
 210   // Assert that MessageLoop::Quit was called by AutoThread::QuitThread.
 211   DCHECK(was_quit_properly_);
 212 }
 213
 214 }  // namespace base