Public Sessions: fetch device robot api token during enterprise enrollment.

chrome/browser/policy/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 CHROME_BROWSER_POLICY_CLOUD_CLOUD_POLICY_CLIENT_H_
 #define CHROME_BROWSER_POLICY_CLOUD_CLOUD_POLICY_CLIENT_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 35 matching lines @@
     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;
 
     // Called upon registration state changes. This callback is invoked for
     // successful completion of registration and unregistration requests.
     virtual void OnRegistrationStateChanged(CloudPolicyClient* client) = 0;
 
+    // Called when a request for device robot OAuth2 authorization tokens
+    // returns successfully. Only occurs during enrollment. Optional
+    // (default implementation is a noop).
+    virtual void OnRobotAuthCodesFetched(CloudPolicyClient* client);
+
     // Indicates there's been an error in a previously-issued request.
     virtual void OnClientError(CloudPolicyClient* client) = 0;
   };
 
   // Delegate interface for supplying status information to upload to the server
   // as part of the policy fetch request.
   class StatusProvider {
    public:
     virtual ~StatusProvider();
 
@@ skipping 34 matching lines @@
 
   // Requests a policy fetch. The client being registered is a prerequisite to
   // this operation and this call will CHECK if the client is not in registered
   // state. FetchPolicy() triggers a policy fetch from the cloud. A policy
   // change notification is reported to the observers and the new policy blob
   // can be retrieved once the policy fetch operation completes. In case of
   // multiple requests to fetch policy, new requests will cancel any pending
   // requests and the latest request will eventually trigger notifications.
   virtual void FetchPolicy();
 
+  // Requests OAuth2 auth codes for the device robot account. The client being
+  // registered is a prerequisite to this operation and this call will CHECK if
+  // the client is not in registered state.
+  virtual void FetchRobotAuthCodes(const std::string& auth_token);
+
   // Sends an unregistration request to the server.
   virtual void Unregister();
 
   // Upload a device certificate to the server.  Like FetchPolicy, this method
   // requires that the client is in a registered state.  |certificate_data| must
   // hold the X.509 certificate data to be sent to the server.  The |callback|
   // will be called when the operation completes.
   virtual void UploadCertificate(const std::string& certificate_data,
                                  const StatusCallback& callback);
 
@@ skipping 44 matching lines @@
 
   // Returns the policy response for |policy_ns_key|, if found in |responses()|;
   // otherwise returns NULL.
   const enterprise_management::PolicyFetchResponse* GetPolicyFor(
       const PolicyNamespaceKey& policy_ns_key) const;
 
   DeviceManagementStatus status() const {
     return status_;
   }
 
+  const std::string& robot_api_auth_code() const {
+    return robot_api_auth_code_;
+  }
+
  protected:
   // A set of PolicyNamespaceKeys to fetch.
   typedef std::set<PolicyNamespaceKey> NamespaceSet;
 
   // Callback for retries of registration requests.
   void OnRetryRegister(DeviceManagementRequestJob* job);
 
   // Callback for registration requests.
   void OnRegisterCompleted(
       DeviceManagementStatus status,
       const enterprise_management::DeviceManagementResponse& response);
 
   // Callback for policy fetch requests.
   void OnPolicyFetchCompleted(
       DeviceManagementStatus status,
       const enterprise_management::DeviceManagementResponse& response);
 
+  // Callback for robot account api authorization requests.
+  void OnFetchRobotAuthCodesCompleted(
+      DeviceManagementStatus status,
+      const enterprise_management::DeviceManagementResponse& response);
+
   // Callback for unregistration requests.
   void OnUnregisterCompleted(
       DeviceManagementStatus status,
       const enterprise_management::DeviceManagementResponse& response);
 
   // Callback for certificate upload requests.
   void OnCertificateUploadCompleted(
       const StatusCallback& callback,
       DeviceManagementStatus status,
       const enterprise_management::DeviceManagementResponse& response);
 
   // Observer notification helpers.
   void NotifyPolicyFetched();
   void NotifyRegistrationStateChanged();
+  void NotifyRobotAuthCodesFetched();
   void NotifyClientError();
 
   // Data necessary for constructing policy requests.
   const std::string machine_id_;
   const std::string machine_model_;
   const UserAffiliation user_affiliation_;
   NamespaceSet namespaces_to_fetch_;
 
   std::string dm_token_;
   DeviceMode device_mode_;
   std::string client_id_;
   bool submit_machine_id_;
   base::Time last_policy_timestamp_;
   int public_key_version_;
   bool public_key_version_valid_;
+  std::string robot_api_auth_code_;
 
   // Used for issuing requests to the cloud.
   DeviceManagementService* service_;
   scoped_ptr<DeviceManagementRequestJob> request_job_;
 
   // Status upload data is produced by |status_provider_|.
   StatusProvider* status_provider_;
 
   // The policy responses returned by the last policy fetch operation.
   ResponseMap responses_;
   DeviceManagementStatus status_;
 
   ObserverList<Observer, true> observers_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CloudPolicyClient);
 };
 
 }  // namespace policy
 
 #endif  // CHROME_BROWSER_POLICY_CLOUD_CLOUD_POLICY_CLIENT_H_