Initial RemoteCommandService

components/policy/core/common/cloud/cloud_policy_client.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 COMPONENTS_POLICY_CORE_COMMON_CLOUD_CLOUD_POLICY_CLIENT_H_
 #define COMPONENTS_POLICY_CORE_COMMON_CLOUD_CLOUD_POLICY_CLIENT_H_
 
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/observer_list.h"
 #include "base/time/time.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
+#include "components/policy/core/common/remote_commands/remote_command_job.h"
 #include "components/policy/policy_export.h"
 #include "policy/proto/device_management_backend.pb.h"
 
 namespace net {
 class URLRequestContextGetter;
 }
 
 namespace policy {
 
 class DeviceManagementRequestJob;
 class DeviceManagementService;
 
 // Implements the core logic required to talk to the device management service.
 // Also keeps track of the current state of the association with the service,
 // such as whether there is a valid registration (DMToken is present in that
 // case) and whether and what errors occurred in the latest request.
 //
 // Note that CloudPolicyClient doesn't do any validation of policy responses
 // such as signature and time stamp checks. These happen once the policy gets
 // installed in the cloud policy cache.
 class POLICY_EXPORT CloudPolicyClient {
  public:
   // Maps a (policy type, settings entity ID) pair to its corresponding
   // PolicyFetchResponse.
-  typedef std::map<std::pair<std::string, std::string>,
-                   enterprise_management::PolicyFetchResponse*> ResponseMap;
+  using ResponseMap = std::map<std::pair<std::string, std::string>,
+                               enterprise_management::PolicyFetchResponse*>;
 
   // A callback which receives boolean status of an operation.  If the operation
   // succeeded, |status| is true.
-  typedef base::Callback<void(bool status)> StatusCallback;
+  using StatusCallback = base::Callback<void(bool status)>;
+
+  // A callback which receives fetched remote commands.
+  using RemoteCommandCallback = base::Callback<void(
+      DeviceManagementStatus,
+      const std::vector<enterprise_management::RemoteCommand>&)>;
 
   // Observer interface for state and policy changes.
   class POLICY_EXPORT Observer {
    public:
     virtual ~Observer();
 
     // Called when a policy fetch completes successfully. If a policy fetch
     // triggers an error, OnClientError() will fire.
     virtual void OnPolicyFetched(CloudPolicyClient* client) = 0;
 
@@ skipping 70 matching lines @@
 
   // Uploads device/session status to the server. As above, the client must be
   // in a registered state. If non-null, |device_status| and |session_status|
   // will be included in the upload status request. The |callback| will be
   // called when the operation completes.
   virtual void UploadDeviceStatus(
       const enterprise_management::DeviceStatusReportRequest* device_status,
       const enterprise_management::SessionStatusReportRequest* session_status,
       const StatusCallback& callback);
 
+  // Attempts to fetch remote commands, with |last_command_id| being the last

[bartfab (slow), 2015/03/12 14:00:55]

What does "recorded" mean here? IIUC, you mean commands that finished running.

[binjin, 2015/03/12 17:58:57]

Done.

+  // recorded command ID and |command_results| being results for previous
+  // commands which have not been reported yet. The |callback| will be called
+  // when the operation completes. A negative last command ID indicates that

[bartfab (slow), 2015/03/12 14:00:55]

Nit: Remove the comment about negative command IDs.

[binjin, 2015/03/12 17:58:57]

Done.

+  // no command was recorded.
+  // Note that sending |last_command_id| will also acknowledge this command,

[bartfab (slow), 2015/03/12 14:00:55]

Nit 1: s/also //
Nit 2: s/, and it can be set to null indicating that there are no recorded
command/. A nullptr indicates that no commands have been recorded yet./

[binjin, 2015/03/12 17:58:57]

Done.

+  // and it can be set to null indicating that there are no recorded command.
+  virtual void FetchRemoteCommands(
+      scoped_ptr<RemoteCommandJob::UniqueIDType> last_command_id,
+      const std::vector<enterprise_management::RemoteCommandResult>&
+          command_results,
+      const RemoteCommandCallback& callback);
+
   // Adds an observer to be called back upon policy and state changes.
   void AddObserver(Observer* observer);
 
   // Removes the specified observer.
   void RemoveObserver(Observer* observer);
 
   void set_submit_machine_id(bool submit_machine_id) {
     submit_machine_id_ = submit_machine_id;
   }
 
@@ skipping 109 matching lines @@
       const enterprise_management::DeviceManagementResponse& response);
 
   // Callback for status upload requests.
   void OnStatusUploadCompleted(
       const DeviceManagementRequestJob* job,
       const StatusCallback& callback,
       DeviceManagementStatus status,
       int net_error,
       const enterprise_management::DeviceManagementResponse& response);
 
+  // Callback for remote command fetch requests.
+  void OnRemoteCommandsFetched(
+      const DeviceManagementRequestJob* job,
+      const RemoteCommandCallback& callback,
+      DeviceManagementStatus status,
+      int net_error,
+      const enterprise_management::DeviceManagementResponse& response);
+
   // Helper to remove a job from request_jobs_.
   void RemoveJob(const DeviceManagementRequestJob* job);
 
   // Observer notification helpers.
   void NotifyPolicyFetched();
   void NotifyRegistrationStateChanged();
   void NotifyRobotAuthCodesFetched();
   void NotifyClientError();
 
   // Data necessary for constructing policy requests.
@@ skipping 38 matching lines @@
   ObserverList<Observer, true> observers_;
   scoped_refptr<net::URLRequestContextGetter> request_context_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CloudPolicyClient);
 };
 
 }  // namespace policy
 
 #endif  // COMPONENTS_POLICY_CORE_COMMON_CLOUD_CLOUD_POLICY_CLIENT_H_