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

remoting/host/plugin/daemon_controller_mac.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 <launch.h>
 #include <stdio.h>
 #include <sys/types.h>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/mac/foundation_util.h"
 #include "base/mac/launchd.h"
 #include "base/mac/mac_logging.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_launch_data.h"
 #include "base/threading/thread.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "remoting/host/constants_mac.h"
 #include "remoting/host/json_host_config.h"
+#include "remoting/host/usage_stats_consent.h"
 
 namespace remoting {
 
 namespace {
 
 // The NSSystemDirectories.h header has a conflicting definition of
 // NSSearchPathDirectory with the one in base/mac/foundation_util.h.
 // Foundation.h would work, but it can only be included from Objective-C files.
 // Therefore, we define the needed constants here.
 const int NSLibraryDirectory = 5;
 
 // Use a single configuration file, instead of separate "auth" and "host" files.
 // This is because the SetConfigAndStart() API only provides a single
 // dictionary, and splitting this into two dictionaries would require
 // knowledge of which keys belong in which files.
 const char kHostConfigFile[] = kHostConfigDir kServiceName ".json";
 
 class DaemonControllerMac : public remoting::DaemonController {
  public:
   DaemonControllerMac();
   virtual ~DaemonControllerMac();
 
   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& callback) OVERRIDE;
 
  private:
   void DoGetConfig(const GetConfigCallback& callback);
   void DoGetVersion(const GetVersionCallback& callback);
   void DoSetConfigAndStart(scoped_ptr<base::DictionaryValue> config,
-                           const CompletionCallback& done_callback);
+                           const CompletionCallback& done);
   void DoUpdateConfig(scoped_ptr<base::DictionaryValue> config,
                       const CompletionCallback& done_callback);
   void DoStop(const CompletionCallback& done_callback);
 
   void ShowPreferencePane(const std::string& config_data,
                           const CompletionCallback& done_callback);
   void RegisterForPreferencePaneNotifications(
       const CompletionCallback &done_callback);
   void DeregisterForPreferencePaneNotifications();
   void PreferencePaneCallbackDelegate(CFStringRef name);
@@ skipping 52 matching lines @@
   // base::Unretained() is safe, since this object owns the thread and therefore
   // outlives it.
   auth_thread_.message_loop_proxy()->PostTask(
       FROM_HERE,
       base::Bind(&DaemonControllerMac::DoGetConfig, base::Unretained(this),
                  callback));
 }
 
 void DaemonControllerMac::SetConfigAndStart(
     scoped_ptr<base::DictionaryValue> config,
-    const CompletionCallback& done_callback) {
+    bool /* consent */,
+    const CompletionCallback& done) {
   auth_thread_.message_loop_proxy()->PostTask(
       FROM_HERE, base::Bind(
           &DaemonControllerMac::DoSetConfigAndStart, base::Unretained(this),
-          base::Passed(&config), done_callback));
+          base::Passed(&config), done));
 }
 
 void DaemonControllerMac::UpdateConfig(
     scoped_ptr<base::DictionaryValue> config,
     const CompletionCallback& done_callback) {
   auth_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
       &DaemonControllerMac::DoUpdateConfig, base::Unretained(this),
       base::Passed(&config), done_callback));
 }
 
 void DaemonControllerMac::Stop(const CompletionCallback& done_callback) {
   auth_thread_.message_loop_proxy()->PostTask(
       FROM_HERE, base::Bind(
           &DaemonControllerMac::DoStop, base::Unretained(this), done_callback));
 }
 
 void DaemonControllerMac::SetWindow(void* window_handle) {
   // noop
 }
 
 void DaemonControllerMac::GetVersion(const GetVersionCallback& callback) {
   auth_thread_.message_loop_proxy()->PostTask(
       FROM_HERE,
       base::Bind(&DaemonControllerMac::DoGetVersion, base::Unretained(this),
                  callback));
 }
 
+void DaemonControllerMac::GetUsageStatsConsent(
+    const GetUsageStatsConsentCallback& callback) {
+  // Crash dump collection is not implemented on Mac yet.
+  // http://crbug.com/130678.
+  callback.Run(false, false, false);
+}
+
 void DaemonControllerMac::DoGetConfig(const GetConfigCallback& callback) {
   FilePath config_path(kHostConfigFile);
   JsonHostConfig host_config(config_path);
   scoped_ptr<base::DictionaryValue> config;
 
   if (host_config.Read()) {
     config.reset(new base::DictionaryValue());
     std::string value;
     if (host_config.GetString(kHostIdConfigPath, &value))
       config.get()->SetString(kHostIdConfigPath, value);
@@ skipping 23 matching lines @@
         }
       }
       version = result;
     }
   }
   callback.Run(version);
 }
 
 void DaemonControllerMac::DoSetConfigAndStart(
     scoped_ptr<base::DictionaryValue> config,
-    const CompletionCallback& done_callback) {
+    const CompletionCallback& done) {
   std::string config_data;
   base::JSONWriter::Write(config.get(), &config_data);
-  ShowPreferencePane(config_data, done_callback);
+  ShowPreferencePane(config_data, done);
 }
 
 void DaemonControllerMac::DoUpdateConfig(
     scoped_ptr<base::DictionaryValue> config,
     const CompletionCallback& done_callback) {
   FilePath config_file_path(kHostConfigFile);
   JsonHostConfig config_file(config_file_path);
   if (!config_file.Read()) {
     done_callback.Run(RESULT_FAILED);
     return;
@@ skipping 132 matching lines @@
   }
 }
 
 }  // namespace
 
 scoped_ptr<DaemonController> remoting::DaemonController::Create() {
   return scoped_ptr<DaemonController>(new DaemonControllerMac());
 }
 
 }  // namespace remoting