Add support for public account policy to CloudPolicyClient.

chrome/browser/policy/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_POLICY_CLIENT_H_
 #define CHROME_BROWSER_POLICY_CLOUD_POLICY_CLIENT_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
 #include "base/time.h"
 #include "chrome/browser/policy/cloud_policy_constants.h"
 #include "chrome/browser/policy/policy_types.h"

[bartfab (slow), 2012/12/03 12:28:40]

Nit: No longer needed.

 
 namespace enterprise_management {
 class DeviceManagementResponse;
 class DeviceRegisterRequest;
 class DeviceStatusReportRequest;
 class PolicyFetchRequest;
 class PolicyFetchResponse;
 class SessionStatusReportRequest;
 }
 
 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 CloudPolicyClient {
  public:
+  // Indicates the type of policy the client should register for and fetch.
+  enum PolicyType {
+    POLICY_TYPE_DEVICE,
+    POLICY_TYPE_USER,
+    POLICY_TYPE_PUBLIC_ACCOUNT,
+  };
+
   // Observer interface for state and policy changes.
   class 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;
 
     // Called upon registration state changes. This callback is invoked for
@@ skipping 20 matching lines @@
     // Called after the status information has successfully been submitted to
     // the server.
     virtual void OnSubmittedSuccessfully() = 0;
   };
 
   // |provider| and |service| are weak pointers and it's the caller's
   // responsibility to keep them valid for the lifetime of CloudPolicyClient.
   CloudPolicyClient(const std::string& machine_id,
                     const std::string& machine_model,
                     UserAffiliation user_affiliation,
-                    PolicyScope scope,
+                    PolicyType policy_type,
                     StatusProvider* provider,
                     DeviceManagementService* service);
   virtual ~CloudPolicyClient();
 
   // Sets the DMToken, thereby establishing a registration with the server. A
   // policy fetch is not automatically issued but can be requested by calling
   // FetchPolicy().
   virtual void SetupRegistration(const std::string& dm_token,
                                  const std::string& client_id);
 
@@ skipping 29 matching lines @@
 
   void set_public_key_version(int public_key_version) {
     public_key_version_ = public_key_version;
     public_key_version_valid_ = true;
   }
 
   void clear_public_key_version() {
     public_key_version_valid_ = false;
   }
 
+  void set_entity_id(const std::string& entity_id) {
+    entity_id_ = entity_id;
+  }
+
   // Whether the client is registered with the device management service.
   bool is_registered() const { return !dm_token_.empty(); }
 
   const std::string& dm_token() const { return dm_token_; }
 
   // The device mode as received in the registration request.
   DeviceMode device_mode() const { return device_mode_; }
 
   // The policy response as obtained by the last request to the cloud. This
   // policy blob hasn't gone through verification, so its contents cannot be
@@ skipping 32 matching lines @@
 
   // Observer notification helpers.
   void NotifyPolicyFetched();
   void NotifyRegistrationStateChanged();
   void NotifyClientError();
 
   // Data necessary for constructing policy requests.
   const std::string machine_id_;
   const std::string machine_model_;
   const UserAffiliation user_affiliation_;
-  const PolicyScope scope_;
+  const PolicyType type_;
 
   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 entity_id_;
 
   // 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 blob returned by the last policy fetch operation.
   scoped_ptr<enterprise_management::PolicyFetchResponse> policy_;
   DeviceManagementStatus status_;
 
   ObserverList<Observer, true> observers_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CloudPolicyClient);
 };
 
 }  // namespace policy
 
 #endif  // CHROME_BROWSER_POLICY_CLOUD_POLICY_CLIENT_H_