Follow up cleanups for r222162.

remoting/host/setup/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_SETUP_DAEMON_CONTROLLER_H_
 #define REMOTING_HOST_SETUP_DAEMON_CONTROLLER_H_
 
 #include <queue>
 #include <string>
 
@@ skipping 68 matching lines @@
       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;
 
   struct UsageStatsConsent {
+    // Indicates whether crash dump reporting is supported by the host.
     bool supported;
+
+    // Indicates if crash dump reporting is allowed by the user.
     bool allowed;
+
+    // Carries information whether the crash dump reporting is controlled by
+    // policy.
     bool set_by_policy;
   };
 
-  // Callback type for GetUsageStatsConsent(). |supported| indicates whether
-  // crash dump reporting is supported by the host. |allowed| indicates if
-  // crash dump reporting is allowed by the user. |set_by_policy| carries
-  // information whether the crash dump reporting is controlled by policy.
+  // Callback type for GetUsageStatsConsent().
   typedef base::Callback<void (const UsageStatsConsent&)>
       GetUsageStatsConsentCallback;
 
   // Interface representing the platform-spacific back-end. Most of its methods
   // are blocking and should called on a background thread. There are two
   // exceptions:
   //   - GetState() is synchronous and called on the UI thread. It should avoid
   //         accessing any data members of the implementation.
-  //   - SetConfigAndStart() is non blocking. |done| callback is posted to
-  //         |task_runner| when the operation completes.
+  //   - SetConfigAndStart(), UpdateConfig() and Stop() indicate completion via
+  //         a callback. There methods are still can be long running and should
+  //         be caled on a background thread.
   class Delegate {
    public:
     virtual ~Delegate() {}
 
     // Return the "installed/running" state of the daemon process. This method
     // should avoid accessing any data members of the implementation.
     virtual State GetState() = 0;
 
     // Queries current host configuration. Any values that might be security
     // sensitive have been filtered out.
     virtual scoped_ptr<base::DictionaryValue> GetConfig() = 0;
 
     // Starts the daemon process. This may require that the daemon be
-    // downloaded and installed. |done| is invoked when the operation is
-    // finished or fails.
+    // downloaded and installed. |done| is invoked on the calling thread when
+    // the operation is completed.
     virtual void SetConfigAndStart(
         scoped_ptr<base::DictionaryValue> config,
         bool consent,
         const CompletionCallback& done) = 0;
 
     // Updates current host configuration with the values specified in
     // |config|. 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.
+    // values, because implementations of this method cannot change them. |done|
+    // is invoked on the calling thread when the operation is completed.
     virtual void UpdateConfig(
         scoped_ptr<base::DictionaryValue> config,
         const CompletionCallback& done) = 0;
 
-    // Stops the daemon process.
+    // Stops the daemon process. |done| is invoked on the calling thread when
+    // the operation is completed.
     virtual void Stop(const CompletionCallback& done) = 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 std::string GetVersion() = 0;
 
@@ skipping 90 matching lines @@
 
   // Queue management methods.
   void ScheduleNext();
   void ServiceOrQueueRequest(const base::Closure& request);
   void ServiceNextRequest();
 
   // Task runner on which all public methods of this class should be called.
   scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner_;
 
   // Task runner used to run blocking calls to the delegate. A single thread
-  // task runner is used to guarantee that one one method of the delegate is
+  // task runner is used to guarantee that one method of the delegate is
   // called at a time.
   scoped_refptr<AutoThreadTaskRunner> delegate_task_runner_;
 
   scoped_ptr<AutoThread> delegate_thread_;
 
   scoped_ptr<Delegate> delegate_;
 
   std::queue<base::Closure> pending_requests_;
 
   DISALLOW_COPY_AND_ASSIGN(DaemonController);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_SETUP_DAEMON_CONTROLLER_H_