The user's consent to crash dumps reporting can now be set via the UI (Windows only). The checkbox …

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"
@@ skipping 10 matching lines @@
 #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 "base/win/windows_version.h"
 #include "remoting/base/scoped_sc_handle_win.h"
 #include "remoting/host/branding.h"
 #include "remoting/host/plugin/daemon_installer_win.h"
+#include "remoting/host/usage_stats_consent.h"
 
 // MIDL-generated declarations and definitions.
 #include "remoting/host/elevated_controller.h"
 
 using base::win::ScopedBstr;
 using base::win::ScopedComPtr;
 
 namespace remoting {
 
 namespace {
@@ skipping 29 matching lines @@
 
 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;
+      bool consent,
+      const CompletionCallback& done) 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;
   virtual void GetVersion(const GetVersionCallback& done_callback) OVERRIDE;
+  virtual void GetUsageStatsConsent(
+      const GetUsageStatsConsentCallback& done) OVERRIDE;
 
  private:
   // Activates an unprivileged instance of the daemon controller and caches it.
   HRESULT ActivateController();
 
   // Activates an elevated instance of the daemon controller and caches it.
   HRESULT ActivateElevatedController();
 
   // Releases the cached instance of the controller.
   void ReleaseController();
 
   // Procedes with the daemon configuration if the installation succeeded,
   // otherwise reports the error.
   void OnInstallationComplete(scoped_ptr<base::DictionaryValue> config,
-                              const CompletionCallback& done_callback,
+                              bool consent,
+                              const CompletionCallback& done,
                               HRESULT result);
 
   // Opens the Chromoting service returning its handle in |service_out|.
   DWORD OpenService(ScopedScHandle* service_out);
 
   // Converts a config dictionary to a scoped BSTR.
   static void ConfigToString(const base::DictionaryValue& config,
                              ScopedBstr* out);
 
   // 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);
 
   // 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,
+                                 bool consent,
                                  const CompletionCallback& done_callback);
   void DoSetConfigAndStart(scoped_ptr<base::DictionaryValue> config,
-                           const CompletionCallback& done_callback);
+                           bool consent,
+                           const CompletionCallback& done);
   void DoUpdateConfig(scoped_ptr<base::DictionaryValue> config,
                       const CompletionCallback& done_callback);
   void DoStop(const CompletionCallback& done_callback);
   void DoSetWindow(void* window_handle);
   void DoGetVersion(const GetVersionCallback& callback);
+  void DoGetUsageStatsConsent(
+      const GetUsageStatsConsentCallback& done);
 
-  // |control_| holds a reference to an instance of the daemon controller
-  // to prevent a UAC prompt on every operation.
+  // |control_| and |control2_| hold references to an instance of the daemon
+  // controller to prevent a UAC prompt on every operation.
   ScopedComPtr<IDaemonControl> control_;
+  ScopedComPtr<IDaemonControl2> control2_;
 
   // True if |control_| holds a reference to an elevated instance of the daemon
   // 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_;
@@ skipping 72 matching lines @@
 
 void DaemonControllerWin::GetConfig(const GetConfigCallback& callback) {
   worker_thread_.message_loop_proxy()->PostTask(
       FROM_HERE,
       base::Bind(&DaemonControllerWin::DoGetConfig,
                  base::Unretained(this), callback));
 }
 
 void DaemonControllerWin::SetConfigAndStart(
     scoped_ptr<base::DictionaryValue> config,
-    const CompletionCallback& done_callback) {
+    bool consent,
+    const CompletionCallback& done) {
   worker_thread_.message_loop_proxy()->PostTask(
       FROM_HERE, base::Bind(
           &DaemonControllerWin::DoInstallAsNeededAndStart,
-          base::Unretained(this), base::Passed(&config), done_callback));
+          base::Unretained(this), base::Passed(&config), consent, done));
 }
 
 void DaemonControllerWin::UpdateConfig(
     scoped_ptr<base::DictionaryValue> config,
     const CompletionCallback& done_callback) {
   worker_thread_.message_loop_proxy()->PostTask(
       FROM_HERE, base::Bind(
           &DaemonControllerWin::DoUpdateConfig,
           base::Unretained(this), base::Passed(&config), done_callback));
 }
@@ skipping 12 matching lines @@
           window_handle));
 }
 
 void DaemonControllerWin::GetVersion(const GetVersionCallback& callback) {
   worker_thread_.message_loop_proxy()->PostTask(
       FROM_HERE,
       base::Bind(&DaemonControllerWin::DoGetVersion,
                  base::Unretained(this), callback));
 }
 
+void DaemonControllerWin::GetUsageStatsConsent(
+    const GetUsageStatsConsentCallback& done) {
+  worker_thread_.message_loop_proxy()->PostTask(
+      FROM_HERE,
+      base::Bind(&DaemonControllerWin::DoGetUsageStatsConsent,
+                 base::Unretained(this), done));
+}
+
 HRESULT DaemonControllerWin::ActivateController() {
   DCHECK(worker_thread_.message_loop_proxy()->BelongsToCurrentThread());
 
   if (control_.get() == NULL) {
     CLSID class_id;
     HRESULT hr = CLSIDFromProgID(kDaemonController, &class_id);
     if (FAILED(hr)) {
       return hr;
     }
 
     hr = CoCreateInstance(class_id, NULL, CLSCTX_LOCAL_SERVER,
                           IID_IDaemonControl, control_.ReceiveVoid());
     if (FAILED(hr)) {
       return hr;
     }
+
+    // Ignore the error. IID_IDaemonControl2 is optional.
+    control_.QueryInterface(IID_IDaemonControl2, control2_.ReceiveVoid());
   }
 
   return S_OK;
 }
 
 HRESULT DaemonControllerWin::ActivateElevatedController() {
   DCHECK(worker_thread_.message_loop_proxy()->BelongsToCurrentThread());
 
   // Release an unprivileged instance of the daemon controller if any.
   if (!control_is_elevated_) {
     ReleaseController();
   }
 
   if (control_.get() == NULL) {
     BIND_OPTS3 bind_options;
     memset(&bind_options, 0, sizeof(bind_options));
     bind_options.cbStruct = sizeof(bind_options);
     bind_options.hwnd = GetTopLevelWindow(window_handle_);
     bind_options.dwClassContext  = CLSCTX_LOCAL_SERVER;
 
     HRESULT hr = ::CoGetObject(
         kDaemonControllerElevationMoniker,
         &bind_options,
         IID_IDaemonControl,
         control_.ReceiveVoid());
     if (FAILED(hr)) {
       return hr;
     }
 
+    // Ignore the error. IID_IDaemonControl2 is optional.
+    control_.QueryInterface(IID_IDaemonControl2, control2_.ReceiveVoid());
+
     // Note that we hold a reference to an elevated instance now.
     control_is_elevated_ = true;
 
     // Release |control_| upon expiration of the timeout.
     release_timer_.reset(new base::OneShotTimer<DaemonControllerWin>());
     release_timer_->Start(FROM_HERE,
                           base::TimeDelta::FromSeconds(kUacTimeoutSec),
                           this,
                           &DaemonControllerWin::ReleaseController);
   }
 
   return S_OK;
 }
 
 void DaemonControllerWin::ReleaseController() {
   DCHECK(worker_thread_.message_loop_proxy()->BelongsToCurrentThread());
 
   control_.Release();
+  control2_.Release();
   release_timer_.reset();
   control_is_elevated_ = false;
 }
 
 void DaemonControllerWin::OnInstallationComplete(
     scoped_ptr<base::DictionaryValue> config,
-    const CompletionCallback& done_callback,
+    bool consent,
+    const CompletionCallback& done,
     HRESULT result) {
   DCHECK(worker_thread_.message_loop_proxy()->BelongsToCurrentThread());
 
   if (SUCCEEDED(result)) {
-    DoSetConfigAndStart(config.Pass(), done_callback);
+    DoSetConfigAndStart(config.Pass(), consent, done);
   } else {
     LOG(ERROR) << "Failed to install the Chromoting Host "
                << "(error: 0x" << std::hex << result << std::dec << ").";
-    done_callback.Run(HResultToAsyncResult(result));
+    done.Run(HResultToAsyncResult(result));
   }
 
   DCHECK(installer_.get() != NULL);
   installer_.reset();
 }
 
 DWORD DaemonControllerWin::OpenService(ScopedScHandle* service_out) {
   // Open the service and query its current state.
   ScopedScHandle scmanager(
       ::OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASE,
@@ skipping 97 matching lines @@
     return;
   }
   // Release |config|, because dictionary points to the same object.
   config.release();
 
   callback.Run(scoped_ptr<base::DictionaryValue>(dictionary));
 }
 
 void DaemonControllerWin::DoInstallAsNeededAndStart(
     scoped_ptr<base::DictionaryValue> config,
-    const CompletionCallback& done_callback) {
+    bool consent,
+    const CompletionCallback& done) {
   DCHECK(worker_thread_.message_loop_proxy()->BelongsToCurrentThread());
 
   // Configure and start the Daemon Controller if it is installed already.
   HRESULT hr = ActivateElevatedController();
   if (SUCCEEDED(hr)) {
-    DoSetConfigAndStart(config.Pass(), done_callback);
+    DoSetConfigAndStart(config.Pass(), consent, done);
     return;
   }
 
   // Otherwise, install it if its COM registration entry is missing.
   if (hr == CO_E_CLASSSTRING) {
     scoped_ptr<DaemonInstallerWin> installer = DaemonInstallerWin::Create(
         GetTopLevelWindow(window_handle_),
         base::Bind(&DaemonControllerWin::OnInstallationComplete,
                    base::Unretained(this),
                    base::Passed(&config),
-                   done_callback));
+                   consent,
+                   done));
     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));
+    done.Run(HResultToAsyncResult(hr));
   }
 }
 
 void DaemonControllerWin::DoSetConfigAndStart(
     scoped_ptr<base::DictionaryValue> config,
-    const CompletionCallback& done_callback) {
+    bool consent,
+    const CompletionCallback& done) {
   DCHECK(worker_thread_.message_loop_proxy()->BelongsToCurrentThread());
 
   HRESULT hr = ActivateElevatedController();
   if (FAILED(hr)) {
-    done_callback.Run(HResultToAsyncResult(hr));
+    done.Run(HResultToAsyncResult(hr));
     return;
   }
 
+  // Record the user's consent.
+  if (control2_.get()) {
+    hr = control2_->SetUsageStatsConsent(consent);
+    if (FAILED(hr)) {
+      done.Run(HResultToAsyncResult(hr));
+      return;
+    }
+  }
+
   // Set the configuration.
   ScopedBstr config_str(NULL);
   ConfigToString(*config, &config_str);
   if (config_str == NULL) {
-    done_callback.Run(HResultToAsyncResult(E_OUTOFMEMORY));
+    done.Run(HResultToAsyncResult(E_OUTOFMEMORY));
     return;
   }
 
   hr = control_->SetOwnerWindow(
       reinterpret_cast<LONG_PTR>(GetTopLevelWindow(window_handle_)));
   if (FAILED(hr)) {
-    done_callback.Run(HResultToAsyncResult(hr));
+    done.Run(HResultToAsyncResult(hr));
     return;
   }
 
   hr = control_->SetConfig(config_str);
   if (FAILED(hr)) {
-    done_callback.Run(HResultToAsyncResult(hr));
+    done.Run(HResultToAsyncResult(hr));
     return;
   }
 
   // Start daemon.
   hr = control_->StartDaemon();
-  done_callback.Run(HResultToAsyncResult(hr));
+  done.Run(HResultToAsyncResult(hr));
 }
 
 void DaemonControllerWin::DoUpdateConfig(
     scoped_ptr<base::DictionaryValue> config,
     const CompletionCallback& done_callback) {
   DCHECK(worker_thread_.message_loop_proxy()->BelongsToCurrentThread());
 
   HRESULT hr = ActivateElevatedController();
   if (FAILED(hr)) {
     done_callback.Run(HResultToAsyncResult(hr));
@@ skipping 54 matching lines @@
   hr = control_->GetVersion(version.Receive());
   if (FAILED(hr)) {
     callback.Run(version_null);
     return;
   }
 
   callback.Run(UTF16ToUTF8(
       string16(static_cast<BSTR>(version), version.Length())));
 }
 
+void DaemonControllerWin::DoGetUsageStatsConsent(
+    const GetUsageStatsConsentCallback& done) {
+  DCHECK(worker_thread_.message_loop_proxy()->BelongsToCurrentThread());
+
+  // Activate the Daemon Controller and see if it supports |IDaemonControl2|.
+  HRESULT hr = ActivateController();
+  if (FAILED(hr) || control2_.get() == NULL) {
+    done.Run(false, false, false);
+    return;
+  }
+
+  // Get the recorded user's consent.
+  BOOL allowed;
+  BOOL set_by_policy;
+  hr = control2_->GetUsageStatsConsent(&allowed, &set_by_policy);
+  if (FAILED(hr)) {
+    done.Run(true, false, false);
+    return;
+  }
+
+  done.Run(true, !!allowed, !!set_by_policy);
+}
+
 }  // namespace
 
 scoped_ptr<DaemonController> remoting::DaemonController::Create() {
   return scoped_ptr<DaemonController>(new DaemonControllerWin());
 }
 
 }  // namespace remoting