remoting/host/setup/daemon_controller.cc

   1 // Copyright 2013 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/host/setup/daemon_controller.h"
   6
   7 #include "base/bind.h"
   8 #include "base/location.h"
   9 #include "base/single_thread_task_runner.h"
  10 #include "base/thread_task_runner_handle.h"
  11 #include "base/values.h"
  12 #include "remoting/base/auto_thread.h"
  13 #include "remoting/base/auto_thread_task_runner.h"
  14
  15 namespace remoting {
  16
  17 // Name of the Daemon Controller's worker thread.
  18 const char kDaemonControllerThreadName[] = "Daemon Controller thread";
  19
  20 DaemonController::DaemonController(scoped_ptr<Delegate> delegate)
  21     : caller_task_runner_(base::ThreadTaskRunnerHandle::Get()),
  22       delegate_(delegate.Pass()) {
  23   // Launch the delegate thread.
  24   delegate_thread_.reset(new AutoThread(kDaemonControllerThreadName));
  25 #if defined(OS_WIN)
  26   delegate_thread_->SetComInitType(AutoThread::COM_INIT_STA);
  27   delegate_task_runner_ =
  28       delegate_thread_->StartWithType(base::MessageLoop::TYPE_UI);
  29 #else
  30   delegate_task_runner_ =
  31       delegate_thread_->StartWithType(base::MessageLoop::TYPE_DEFAULT);
  32 #endif
  33 }
  34
  35 DaemonController::State DaemonController::GetState() {
  36   DCHECK(caller_task_runner_->BelongsToCurrentThread());
  37   return delegate_->GetState();
  38 }
  39
  40 void DaemonController::GetConfig(const GetConfigCallback& done) {
  41   DCHECK(caller_task_runner_->BelongsToCurrentThread());
  42
  43   DaemonController::GetConfigCallback wrapped_done = base::Bind(
  44       &DaemonController::InvokeConfigCallbackAndScheduleNext, this, done);
  45   base::Closure request = base::Bind(
  46       &DaemonController::DoGetConfig, this, wrapped_done);
  47   ServiceOrQueueRequest(request);
  48 }
  49
  50 void DaemonController::InstallHost(const CompletionCallback& done) {
  51   DCHECK(caller_task_runner_->BelongsToCurrentThread());
  52
  53   DaemonController::CompletionCallback wrapped_done = base::Bind(
  54       &DaemonController::InvokeCompletionCallbackAndScheduleNext, this, done);
  55   base::Closure request = base::Bind(
  56       &DaemonController::DoInstallHost, this, wrapped_done);
  57   ServiceOrQueueRequest(request);
  58 }
  59
  60 void DaemonController::SetConfigAndStart(
  61     scoped_ptr<base::DictionaryValue> config,
  62     bool consent,
  63     const CompletionCallback& done) {
  64   DCHECK(caller_task_runner_->BelongsToCurrentThread());
  65
  66   DaemonController::CompletionCallback wrapped_done = base::Bind(
  67       &DaemonController::InvokeCompletionCallbackAndScheduleNext, this, done);
  68   base::Closure request = base::Bind(
  69       &DaemonController::DoSetConfigAndStart, this, base::Passed(&config),
  70       consent, wrapped_done);
  71   ServiceOrQueueRequest(request);
  72 }
  73
  74 void DaemonController::UpdateConfig(scoped_ptr<base::DictionaryValue> config,
  75                                     const CompletionCallback& done) {
  76   DCHECK(caller_task_runner_->BelongsToCurrentThread());
  77
  78   DaemonController::CompletionCallback wrapped_done = base::Bind(
  79       &DaemonController::InvokeCompletionCallbackAndScheduleNext, this, done);
  80   base::Closure request = base::Bind(
  81       &DaemonController::DoUpdateConfig, this, base::Passed(&config),
  82       wrapped_done);
  83   ServiceOrQueueRequest(request);
  84 }
  85
  86 void DaemonController::Stop(const CompletionCallback& done) {
  87   DCHECK(caller_task_runner_->BelongsToCurrentThread());
  88
  89   DaemonController::CompletionCallback wrapped_done = base::Bind(
  90       &DaemonController::InvokeCompletionCallbackAndScheduleNext, this, done);
  91   base::Closure request = base::Bind(
  92       &DaemonController::DoStop, this, wrapped_done);
  93   ServiceOrQueueRequest(request);
  94 }
  95
  96 void DaemonController::SetWindow(void* window_handle) {
  97   DCHECK(caller_task_runner_->BelongsToCurrentThread());
  98
  99   base::Closure done = base::Bind(&DaemonController::ScheduleNext, this);
 100   base::Closure request = base::Bind(
 101       &DaemonController::DoSetWindow, this, window_handle, done);
 102   ServiceOrQueueRequest(request);
 103 }
 104
 105 void DaemonController::GetVersion(const GetVersionCallback& done) {
 106   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 107
 108   DaemonController::GetVersionCallback wrapped_done = base::Bind(
 109       &DaemonController::InvokeVersionCallbackAndScheduleNext, this, done);
 110   base::Closure request = base::Bind(
 111       &DaemonController::DoGetVersion, this, wrapped_done);
 112   ServiceOrQueueRequest(request);
 113 }
 114
 115 void DaemonController::GetUsageStatsConsent(
 116     const GetUsageStatsConsentCallback& done) {
 117   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 118
 119   DaemonController::GetUsageStatsConsentCallback wrapped_done = base::Bind(
 120       &DaemonController::InvokeConsentCallbackAndScheduleNext, this, done);
 121   base::Closure request = base::Bind(
 122       &DaemonController::DoGetUsageStatsConsent, this, wrapped_done);
 123   ServiceOrQueueRequest(request);
 124 }
 125
 126 DaemonController::~DaemonController() {
 127   // Make sure |delegate_| is deleted on the background thread.
 128   delegate_task_runner_->DeleteSoon(FROM_HERE, delegate_.release());
 129
 130   // Stop the thread.
 131   delegate_task_runner_ = NULL;
 132   caller_task_runner_->DeleteSoon(FROM_HERE, delegate_thread_.release());
 133 }
 134
 135 void DaemonController::DoGetConfig(const GetConfigCallback& done) {
 136   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 137
 138   scoped_ptr<base::DictionaryValue> config = delegate_->GetConfig();
 139   caller_task_runner_->PostTask(FROM_HERE,
 140                                 base::Bind(done, base::Passed(&config)));
 141 }
 142
 143 void DaemonController::DoInstallHost(const CompletionCallback& done) {
 144   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 145
 146   delegate_->InstallHost(done);
 147 }
 148
 149 void DaemonController::DoSetConfigAndStart(
 150     scoped_ptr<base::DictionaryValue> config,
 151     bool consent,
 152     const CompletionCallback& done) {
 153   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 154
 155   delegate_->SetConfigAndStart(config.Pass(), consent, done);
 156 }
 157
 158 void DaemonController::DoUpdateConfig(
 159     scoped_ptr<base::DictionaryValue> config,
 160     const CompletionCallback& done) {
 161   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 162
 163   delegate_->UpdateConfig(config.Pass(), done);
 164 }
 165
 166 void DaemonController::DoStop(const CompletionCallback& done) {
 167   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 168
 169   delegate_->Stop(done);
 170 }
 171
 172 void DaemonController::DoSetWindow(void* window_handle,
 173                                    const base::Closure& done) {
 174   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 175
 176   delegate_->SetWindow(window_handle);
 177   caller_task_runner_->PostTask(FROM_HERE, done);
 178 }
 179
 180 void DaemonController::DoGetVersion(const GetVersionCallback& done) {
 181   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 182
 183   std::string version = delegate_->GetVersion();
 184   caller_task_runner_->PostTask(FROM_HERE, base::Bind(done, version));
 185 }
 186
 187 void DaemonController::DoGetUsageStatsConsent(
 188     const GetUsageStatsConsentCallback& done) {
 189   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
 190
 191   DaemonController::UsageStatsConsent consent =
 192       delegate_->GetUsageStatsConsent();
 193   caller_task_runner_->PostTask(FROM_HERE, base::Bind(done, consent));
 194 }
 195
 196 void DaemonController::InvokeCompletionCallbackAndScheduleNext(
 197     const CompletionCallback& done,
 198     AsyncResult result) {
 199   if (!caller_task_runner_->BelongsToCurrentThread()) {
 200     caller_task_runner_->PostTask(
 201         FROM_HERE,
 202         base::Bind(&DaemonController::InvokeCompletionCallbackAndScheduleNext,
 203                    this, done, result));
 204     return;
 205   }
 206
 207   done.Run(result);
 208   ScheduleNext();
 209 }
 210
 211 void DaemonController::InvokeConfigCallbackAndScheduleNext(
 212     const GetConfigCallback& done,
 213     scoped_ptr<base::DictionaryValue> config) {
 214   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 215
 216   done.Run(config.Pass());
 217   ScheduleNext();
 218 }
 219
 220 void DaemonController::InvokeConsentCallbackAndScheduleNext(
 221     const GetUsageStatsConsentCallback& done,
 222     const UsageStatsConsent& consent) {
 223   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 224
 225   done.Run(consent);
 226   ScheduleNext();
 227 }
 228
 229 void DaemonController::InvokeVersionCallbackAndScheduleNext(
 230     const GetVersionCallback& done,
 231     const std::string& version) {
 232   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 233
 234   done.Run(version);
 235   ScheduleNext();
 236 }
 237
 238 void DaemonController::ScheduleNext() {
 239   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 240
 241   pending_requests_.pop();
 242   ServiceNextRequest();
 243 }
 244
 245 void DaemonController::ServiceOrQueueRequest(const base::Closure& request) {
 246   bool servicing_request = !pending_requests_.empty();
 247   pending_requests_.push(request);
 248   if (!servicing_request)
 249     ServiceNextRequest();
 250 }
 251
 252 void DaemonController::ServiceNextRequest() {
 253   if (!pending_requests_.empty())
 254     delegate_task_runner_->PostTask(FROM_HERE, pending_requests_.front());
 255 }
 256
 257 }  // namespace remoting