Windows chromoting host installation via the NPAPI plugin

remoting/host/setup/daemon_controller_delegate_win.cc

 // Copyright 2013 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_delegate_win.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "base/values.h"
 #include "base/win/scoped_bstr.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"
 // chromoting_lib.h contains MIDL-generated declarations.
 #include "remoting/host/chromoting_lib.h"
-#include "remoting/host/setup/daemon_installer_win.h"
 #include "remoting/host/usage_stats_consent.h"
 
 using base::win::ScopedBstr;
 using base::win::ScopedComPtr;
 
 namespace remoting {
 
 namespace {
 
 // ProgID of the daemon controller.
@@ skipping 83 matching lines @@
     return DaemonController::RESULT_OK;
   } else if (hr == HRESULT_FROM_WIN32(ERROR_CANCELLED)) {
     return DaemonController::RESULT_CANCELLED;
   } else {
     // TODO(sergeyu): Report other errors to the webapp once it knows
     // how to handle them.
     return DaemonController::RESULT_FAILED;
   }
 }
 
+void InvokeCompletionCallback(
+    const DaemonController::CompletionCallback& done, HRESULT hr) {
+  done.Run(HResultToAsyncResult(hr));
+}
+
 }  // namespace
 
 DaemonControllerDelegateWin::DaemonControllerDelegateWin()
     : control_is_elevated_(false),
       window_handle_(NULL) {
 }
 
 DaemonControllerDelegateWin::~DaemonControllerDelegateWin() {
 }
 
@@ skipping 45 matching lines @@
       base::JSONReader::Read(base::UTF16ToUTF8(file_content),
           base::JSON_ALLOW_TRAILING_COMMAS));
 
   if (!config || config->GetType() != base::Value::TYPE_DICTIONARY)
     return scoped_ptr<base::DictionaryValue>();
 
   return scoped_ptr<base::DictionaryValue>(
       static_cast<base::DictionaryValue*>(config.release()));
 }
 
+void DaemonControllerDelegateWin::InstallHost(
+    const DaemonController::CompletionCallback& done) {
+  DoInstallHost(base::Bind(&InvokeCompletionCallback, done));
+}
+
 void DaemonControllerDelegateWin::SetConfigAndStart(
     scoped_ptr<base::DictionaryValue> config,
     bool consent,
     const DaemonController::CompletionCallback& done) {
+  DoInstallHost(
+      base::Bind(&DaemonControllerDelegateWin::StartHostWithConfig,
+                 base::Unretained(this), base::Passed(&config), consent, done));
+}
+
+void DaemonControllerDelegateWin::DoInstallHost(
+    const DaemonInstallerWin::CompletionCallback& done) {
   // Configure and start the Daemon Controller if it is installed already.
   HRESULT hr = ActivateElevatedController();
   if (SUCCEEDED(hr)) {
-    OnInstallationComplete(config.Pass(), consent, done, S_OK);
+    done.Run(S_OK);
     return;
   }
 
   // Otherwise, install it if its COM registration entry is missing.
   if (hr == CO_E_CLASSSTRING) {
     DCHECK(!installer_);
 
     installer_ = DaemonInstallerWin::Create(
-        GetTopLevelWindow(window_handle_),
-        base::Bind(&DaemonControllerDelegateWin::OnInstallationComplete,
-                   base::Unretained(this),
-                   base::Passed(&config),
-                   consent,
-                   done));
+        GetTopLevelWindow(window_handle_), done);
     installer_->Install();
     return;
   }
 
   LOG(ERROR) << "Failed to initiate the Chromoting Host installation "
              << "(error: 0x" << std::hex << hr << std::dec << ").";
-  done.Run(HResultToAsyncResult(hr));
+  done.Run(hr);
 }
 
 void DaemonControllerDelegateWin::UpdateConfig(
     scoped_ptr<base::DictionaryValue> config,
     const DaemonController::CompletionCallback& done) {
   HRESULT hr = ActivateElevatedController();
   if (FAILED(hr)) {
-    done.Run(HResultToAsyncResult(hr));
+    InvokeCompletionCallback(done, hr);
     return;
   }
 
   // Update the configuration.
   ScopedBstr config_str(NULL);
   ConfigToString(*config, &config_str);
   if (config_str == NULL) {
-    done.Run(HResultToAsyncResult(E_OUTOFMEMORY));
+    InvokeCompletionCallback(done, E_OUTOFMEMORY);
     return;
   }
 
   // Make sure that the PIN confirmation dialog is focused properly.
   hr = control_->SetOwnerWindow(
       reinterpret_cast<LONG_PTR>(GetTopLevelWindow(window_handle_)));
   if (FAILED(hr)) {
-    done.Run(HResultToAsyncResult(hr));
+    InvokeCompletionCallback(done, hr);
     return;
   }
 
   hr = control_->UpdateConfig(config_str);
-  done.Run(HResultToAsyncResult(hr));
+  InvokeCompletionCallback(done, hr);
 }
 
 void DaemonControllerDelegateWin::Stop(
     const DaemonController::CompletionCallback& done) {
   HRESULT hr = ActivateElevatedController();
   if (SUCCEEDED(hr))
     hr = control_->StopDaemon();
 
-  done.Run(HResultToAsyncResult(hr));
+  InvokeCompletionCallback(done, hr);
 }
 
 void DaemonControllerDelegateWin::SetWindow(void* window_handle) {
   window_handle_ = reinterpret_cast<HWND>(window_handle);
 }
 
 std::string DaemonControllerDelegateWin::GetVersion() {
   // Configure and start the Daemon Controller if it is installed already.
   HRESULT hr = ActivateController();
   if (FAILED(hr))
@@ skipping 114 matching lines @@
   return S_OK;
 }
 
 void DaemonControllerDelegateWin::ReleaseController() {
   control_.Release();
   control2_.Release();
   release_timer_.reset();
   control_is_elevated_ = false;
 }
 
-void DaemonControllerDelegateWin::OnInstallationComplete(
+void DaemonControllerDelegateWin::StartHostWithConfig(
     scoped_ptr<base::DictionaryValue> config,
     bool consent,
     const DaemonController::CompletionCallback& done,
     HRESULT hr) {
   installer_.reset();
 
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to install the Chromoting Host "
                << "(error: 0x" << std::hex << hr << std::dec << ").";
-    done.Run(HResultToAsyncResult(hr));
+    InvokeCompletionCallback(done, hr);
     return;
   }
 
   hr = ActivateElevatedController();
   if (FAILED(hr)) {
-    done.Run(HResultToAsyncResult(hr));
+    InvokeCompletionCallback(done, hr);
     return;
   }
 
   // Record the user's consent.
   if (control2_) {
     hr = control2_->SetUsageStatsConsent(consent);
     if (FAILED(hr)) {
-      done.Run(HResultToAsyncResult(hr));
+      InvokeCompletionCallback(done, hr);
       return;
     }
   }
 
   // Set the configuration.
   ScopedBstr config_str(NULL);
   ConfigToString(*config, &config_str);
   if (config_str == NULL) {
-    done.Run(HResultToAsyncResult(E_OUTOFMEMORY));
+    InvokeCompletionCallback(done, E_OUTOFMEMORY);
     return;
   }
 
   hr = control_->SetOwnerWindow(
       reinterpret_cast<LONG_PTR>(GetTopLevelWindow(window_handle_)));
   if (FAILED(hr)) {
-    done.Run(HResultToAsyncResult(hr));
+    InvokeCompletionCallback(done, hr);
     return;
   }
 
   hr = control_->SetConfig(config_str);
   if (FAILED(hr)) {
-    done.Run(HResultToAsyncResult(hr));
+    InvokeCompletionCallback(done, hr);
     return;
   }
 
   // Start daemon.
   hr = control_->StartDaemon();
-  done.Run(HResultToAsyncResult(hr));
+  InvokeCompletionCallback(done, hr);
 }
 
 scoped_refptr<DaemonController> DaemonController::Create() {
   scoped_ptr<DaemonController::Delegate> delegate(
       new DaemonControllerDelegateWin());
   return new DaemonController(delegate.Pass());
 }
 
 }  // namespace remoting