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

remoting/host/plugin/daemon_controller.h

 // 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.
 
 #ifndef REMOTING_HOST_DAEMON_CONTROLLER_H_
 #define REMOTING_HOST_DAEMON_CONTROLLER_H_
 
 #include <string>
 
 #include "base/callback_forward.h"
@@ skipping 61 matching lines @@
   typedef base::Callback<void (scoped_ptr<base::DictionaryValue> config)>
       GetConfigCallback;
 
   // Callback used for asynchronous operations, e.g. when
   // starting/stopping the service.
   typedef base::Callback<void (AsyncResult result)> CompletionCallback;
 
   // Callback type for GetVersion().
   typedef base::Callback<void (const std::string&)> GetVersionCallback;
 
+  // Callback type for GetUsageStatsConsent().
+  typedef base::Callback<void (bool, bool, bool)> GetUsageStatsConsentCallback;

[Jamie, 2012/06/21 18:47:52]

I think this typedef could do with documentation to explain what the three bools
represent.

[alexeypa (please no reviews), 2012/06/21 23:30:26]

Done.

+
   virtual ~DaemonController() {}
 
   // Return the "installed/running" state of the daemon process.
   //
   // TODO(sergeyu): This method is called synchronously from the
   // webapp. In most cases it requires IO operations, so it may block
   // the user interface. Replace it with asynchronous notifications,
   // e.g. with StartStateNotifications()/StopStateNotifications() methods.
   virtual State GetState() = 0;
 
   // Queries current host configuration. The |callback| is called
   // after the configuration is read, and any values that might be security
   // sensitive have been filtered out.
   virtual void GetConfig(const GetConfigCallback& callback) = 0;
 
   // Start the daemon process. This may require that the daemon be
   // downloaded and installed. |done_callback| is called when the
   // operation is finished or fails.
   //
   // TODO(sergeyu): This method writes config and starts the host -
   // these two steps are merged for simplicity. Consider splitting it
   // into SetConfig() and Start() once we have basic host setup flow
   // working.
   virtual void SetConfigAndStart(scoped_ptr<base::DictionaryValue> config,
-                                 const CompletionCallback& done_callback) = 0;
+                                 bool consent,
+                                 const CompletionCallback& done) = 0;
 
   // Updates current host configuration with the values specified in
   // |config|. Changes must take effect before the call completes.
   // Any value in the existing configuration that isn't specified in |config|
   // is preserved. |config| must not contain host_id or xmpp_login values,
   // because implementations of this method cannot change them.
   virtual void UpdateConfig(scoped_ptr<base::DictionaryValue> config,
                             const CompletionCallback& done_callback) = 0;
 
   // Stop the daemon process. It is permitted to call Stop while the daemon
   // process is being installed, in which case the installation should be
   // aborted if possible; if not then it is sufficient to ensure that the
   // daemon process is not started automatically upon successful installation.
   // As with Start, Stop may return before the operation is complete--poll
   // GetState until the state is STATE_STOPPED.
   virtual void Stop(const CompletionCallback& done_callback) = 0;
 
   // Caches the native handle of the plugin window so it can be used to focus
   // elevation prompts properly.
   virtual void SetWindow(void* window_handle) = 0;
 
   // Get the version of the daemon as a dotted decimal string of the form
   // major.minor.build.patch, if it is installed, or "" otherwise.
   virtual void GetVersion(const GetVersionCallback& done_callback) = 0;
 
+  // Get the user's consent to crash reporting.
+  virtual void GetUsageStatsConsent(
+      const GetUsageStatsConsentCallback& done) = 0;
+
   static scoped_ptr<DaemonController> Create();
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_DAEMON_CONTROLLER_H_