Making sure that UAC promts fired by the Chromoting plugin get focus (instead of being shown in the…

remoting/host/plugin/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/plugin/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/stringize_macros.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_comptr.h"
 #include "remoting/base/scoped_sc_handle_win.h"
 #include "remoting/host/branding.h"
 #include "remoting/host/daemon_controller_common_win.h"
 #include "remoting/host/plugin/daemon_installer_win.h"
 
 // MIDL-generated declarations and definitions.
 #include "remoting/host/elevated_controller.h"
 
 using base::win::ScopedBstr;
 using base::win::ScopedComPtr;
 
 namespace remoting {
 
 namespace {
 
-// The COM elevation moniker for the elevated controller.
+// The COM elevation moniker for the Elevated Controller.
 const char16 kDaemonControllerElevationMoniker[] =
     TO_L_STRING("Elevation:Administrator!new:")
     TO_L_STRING("ChromotingElevatedController.ElevatedController");
 
 // Name of the Daemon Controller's worker thread.
 const char kDaemonControllerThreadName[] = "Daemon Controller thread";
 
+// The maximum interval between showing UAC prompts.
+const int kUacTimeoutSec = 15 * 60;

[Jamie, 2012/04/25 21:20:37]

Is this strictly needed as part of this CL? It feels sufficiently complex to
warrant a follow-up.

[alexeypa (please no reviews), 2012/04/25 21:59:24]

I'll move it to a separate CL.

+
 // A base::Thread implementation that initializes COM on the new thread.
 class ComThread : public base::Thread {
  public:
   explicit ComThread(const char* name);
 
   // Activates an elevated instance of the controller and returns the pointer
   // to the control interface in |control_out|. This class keeps the ownership
   // of the pointer so the caller should not call call AddRef() or Release().
-  HRESULT ActivateElevatedController(IDaemonControl** control_out);
+  HRESULT ActivateElevatedController(void* window_handle,

[Jamie, 2012/04/25 21:20:37]

HWND?

[alexeypa (please no reviews), 2012/04/25 21:59:24]

Done.

+                                     IDaemonControl** control_out);
 
   bool Start();
 
  protected:
   virtual void Init() OVERRIDE;
   virtual void CleanUp() OVERRIDE;
 
+  void ReleaseElevatedController();
+
   ScopedComPtr<IDaemonControl> control_;
 
+  // This timer is used to release |control_| after a timeout.
+  base::OneShotTimer<ComThread> release_timer_;
+
   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,
       const CompletionCallback& done_callback) OVERRIDE;
   virtual void UpdateConfig(scoped_ptr<base::DictionaryValue> config,
                             const CompletionCallback& done_callback) OVERRIDE;
   virtual void Stop(const CompletionCallback& done_callback) OVERRIDE;
+  virtual void SetWindow(void* window_handle) OVERRIDE;
 
  private:
   // Converts a Windows service status code to a Daemon state.
   static State ConvertToDaemonState(DWORD service_state);
 
   // Converts HRESULT to the AsyncResult.
   static AsyncResult HResultToAsyncResult(HRESULT hr);
 
   // Procedes with the daemon configuration if the installation succeeded,
   // otherwise reports the error.
   void OnInstallationComplete(scoped_ptr<base::DictionaryValue> config,
                               const CompletionCallback& done_callback,
                               HRESULT result);
 
   // Opens the Chromoting service returning its handle in |service_out|.
   DWORD OpenService(ScopedScHandle* service_out);
 
   // The functions that actually do the work. They should be called in
   // the context of |worker_thread_|;
   void DoGetConfig(const GetConfigCallback& callback);
   void DoInstallAsNeededAndStart(scoped_ptr<base::DictionaryValue> config,
                                  const CompletionCallback& done_callback);
   void DoSetConfigAndStart(scoped_ptr<base::DictionaryValue> config,
                            const CompletionCallback& done_callback);
   void DoUpdateConfig(scoped_ptr<base::DictionaryValue> config,
                       const CompletionCallback& done_callback);
   void DoStop(const CompletionCallback& done_callback);
+  void DoSetWindow(void* window_handle);
+
+  // Handle of the plugin window.
+  void* window_handle_;

[Jamie, 2012/04/25 21:20:37]

Store as an HWND?

[alexeypa (please no reviews), 2012/04/25 21:59:24]

Done.

 
   // The worker thread used for servicing long running operations.
   ComThread worker_thread_;
 
   scoped_ptr<DaemonInstallerWin> installer_;
 
   DISALLOW_COPY_AND_ASSIGN(DaemonControllerWin);
 };
 
 ComThread::ComThread(const char* name) : base::Thread(name), control_(NULL) {
 }
 
-void ComThread::Init() {
-  CoInitialize(NULL);
-}
-
-void ComThread::CleanUp() {
-  control_.Release();
-  CoUninitialize();
-}
-
 HRESULT ComThread::ActivateElevatedController(
+    void* window_handle,
     IDaemonControl** control_out) {
-  // Chache the instance of Elevated Controller to prevent a UAC prompt on every
-  // operation.
+  // Cache an instance of the Elevated Controller to prevent a UAC prompt on
+  // every operation.
   if (control_.get() == NULL) {
     BIND_OPTS3 bind_options;
     memset(&bind_options, 0, sizeof(bind_options));
     bind_options.cbStruct = sizeof(bind_options);
-    bind_options.hwnd = NULL;
+    bind_options.hwnd =
+        GetTopLevelWindow(reinterpret_cast<HWND>(window_handle));
     bind_options.dwClassContext  = CLSCTX_LOCAL_SERVER;
 
     HRESULT hr = ::CoGetObject(
         kDaemonControllerElevationMoniker,
         &bind_options,
         IID_IDaemonControl,
         control_.ReceiveVoid());
     if (FAILED(hr)) {
       return hr;
     }
+
+    // Release |control_| upon expiration of the timeout.
+    release_timer_.Start(FROM_HERE,
+                         base::TimeDelta::FromSeconds(kUacTimeoutSec),
+                         this, &ComThread::ReleaseElevatedController);
   }
 
   *control_out = control_.get();
   return S_OK;
 }
 
 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() {
+  CoInitialize(NULL);
+}
+
+void ComThread::CleanUp() {
+  ReleaseElevatedController();
+  CoUninitialize();
+}
+
+void ComThread::ReleaseElevatedController() {
+  control_.Release();
+}
+

[Jamie, 2012/04/25 21:20:37]

It's not clear to me which of the previous functions are needed for the UAC
parenting and which are for the timeout, nor why Co[Un]initialize is needed now
and wasn't earlier.

[alexeypa (please no reviews), 2012/04/25 21:59:24]

I'll move the timeout change to a separate CL.
ComThread::Init() & ComThread::CleanUp() were moved to comply with the style
guide. 

 DaemonControllerWin::DaemonControllerWin()
-    : worker_thread_(kDaemonControllerThreadName) {
+    : window_handle_(NULL),
+      worker_thread_(kDaemonControllerThreadName) {
   if (!worker_thread_.Start()) {
     LOG(FATAL) << "Failed to start the Daemon Controller worker thread.";
   }
 }
 
 DaemonControllerWin::~DaemonControllerWin() {
   worker_thread_.Stop();
 }
 
 remoting::DaemonController::State DaemonControllerWin::GetState() {
@@ skipping 47 matching lines @@
           base::Unretained(this), base::Passed(&config), done_callback));
 }
 
 void DaemonControllerWin::Stop(const CompletionCallback& done_callback) {
   worker_thread_.message_loop_proxy()->PostTask(
       FROM_HERE, base::Bind(
           &DaemonControllerWin::DoStop, base::Unretained(this),
           done_callback));
 }
 
+void DaemonControllerWin::SetWindow(void* window_handle) {
+  worker_thread_.message_loop_proxy()->PostTask(
+      FROM_HERE, base::Bind(
+          &DaemonControllerWin::DoSetWindow, base::Unretained(this),
+          window_handle));
+}
+
 // static
 remoting::DaemonController::State DaemonControllerWin::ConvertToDaemonState(
     DWORD service_state) {
   switch (service_state) {
   case SERVICE_RUNNING:
     return STATE_STARTED;
 
   case SERVICE_CONTINUE_PENDING:
   case SERVICE_START_PENDING:
     return STATE_STARTING;
@@ skipping 120 matching lines @@
 
   callback.Run(scoped_ptr<base::DictionaryValue>(dictionary));
 }
 
 void DaemonControllerWin::DoInstallAsNeededAndStart(
     scoped_ptr<base::DictionaryValue> config,
     const CompletionCallback& done_callback) {
   DCHECK(worker_thread_.message_loop_proxy()->BelongsToCurrentThread());
 
   IDaemonControl* control = NULL;
-  HRESULT hr = worker_thread_.ActivateElevatedController(&control);
+  HRESULT hr = worker_thread_.ActivateElevatedController(window_handle_,
+                                                         &control);
 
   // Just configure and start the Daemon Controller if it is installed already.
   if (SUCCEEDED(hr)) {
     DoSetConfigAndStart(config.Pass(), done_callback);
     return;
   }
 
   // Otherwise, install it if its COM registration entry is missing.
   if (hr == CO_E_CLASSSTRING) {
     scoped_ptr<DaemonInstallerWin> installer = DaemonInstallerWin::Create(
+        window_handle_,
         base::Bind(&DaemonControllerWin::OnInstallationComplete,
                    base::Unretained(this),
                    base::Passed(&config),
                    done_callback));
     if (installer.get()) {
       DCHECK(!installer_.get());
       installer_ = installer.Pass();
       installer_->Install();
     }
   } else {
     LOG(ERROR) << "Failed to initiate the Chromoting Host installation "
                << "(error: 0x" << std::hex << hr << std::dec << ").";
     done_callback.Run(HResultToAsyncResult(hr));
   }
 }
 
 void DaemonControllerWin::DoSetConfigAndStart(
     scoped_ptr<base::DictionaryValue> config,
     const CompletionCallback& done_callback) {
   DCHECK(worker_thread_.message_loop_proxy()->BelongsToCurrentThread());
 
   IDaemonControl* control = NULL;
-  HRESULT hr = worker_thread_.ActivateElevatedController(&control);
+  HRESULT hr = worker_thread_.ActivateElevatedController(window_handle_,
+                                                         &control);
   if (FAILED(hr)) {
     done_callback.Run(HResultToAsyncResult(hr));
     return;
   }
 
   // Store the configuration.
   std::string file_content;
   base::JSONWriter::Write(config.get(), &file_content);
 
   ScopedBstr host_config(UTF8ToUTF16(file_content).c_str());
@@ skipping 14 matching lines @@
 }
 
 void DaemonControllerWin::DoUpdateConfig(
     scoped_ptr<base::DictionaryValue> config,
     const CompletionCallback& done_callback) {
   // TODO(simonmorris): Much of this code was copied from DoSetConfigAndStart().
   // Refactor.
   DCHECK(worker_thread_.message_loop_proxy()->BelongsToCurrentThread());
 
   IDaemonControl* control = NULL;
-  HRESULT hr = worker_thread_.ActivateElevatedController(&control);
+  HRESULT hr = worker_thread_.ActivateElevatedController(window_handle_,
+                                                         &control);
   if (FAILED(hr)) {
     done_callback.Run(HResultToAsyncResult(hr));
     return;
   }
 
   // Store the configuration.
   std::string file_content;
   base::JSONWriter::Write(config.get(), &file_content);
 
   ScopedBstr host_config(UTF8ToUTF16(file_content).c_str());
   if (host_config == NULL) {
     done_callback.Run(HResultToAsyncResult(E_OUTOFMEMORY));
     return;
   }
 
   hr = control->UpdateConfig(host_config);
   done_callback.Run(HResultToAsyncResult(hr));
 }
 
 void DaemonControllerWin::DoStop(const CompletionCallback& done_callback) {
   DCHECK(worker_thread_.message_loop_proxy()->BelongsToCurrentThread());
 
   IDaemonControl* control = NULL;
-  HRESULT hr = worker_thread_.ActivateElevatedController(&control);
+  HRESULT hr = worker_thread_.ActivateElevatedController(window_handle_,
+                                                         &control);
   if (FAILED(hr)) {
     done_callback.Run(HResultToAsyncResult(hr));
     return;
   }
 
   hr = control->StopDaemon();
   done_callback.Run(HResultToAsyncResult(hr));
 }
 
+void DaemonControllerWin::DoSetWindow(void* window_handle) {
+  window_handle_ = window_handle;
+}
+
 }  // namespace
 
 scoped_ptr<DaemonController> remoting::DaemonController::Create() {
   return scoped_ptr<DaemonController>(new DaemonControllerWin());
 }
 
 }  // namespace remoting