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 30 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.
+    virtual void OnRobotAuthCodesFetched(CloudPolicyClient* client) = 0;
+
     // 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 tokens 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 FetchRobotAuthTokens(const std::string& auth_token);
+
   // Sends an unregistration request to the server.
   virtual void Unregister();
 
   // 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) {
@@ skipping 37 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 OnFetchRobotAuthTokensCompleted(
+      DeviceManagementStatus status,
+      const enterprise_management::DeviceManagementResponse& response);
+
   // Callback for unregistration requests.
   void OnUnregisterCompleted(
       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_