Removed policy::PolicyNamespaceKey.

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/observer_list.h"
 #include "base/time/time.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "components/policy/policy_export.h"
 #include "policy/proto/device_management_backend.pb.h"
@@ skipping 10 matching lines @@
 // 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 PolicyNamespaceKey to its corresponding PolicyFetchResponse.
-  typedef std::map<PolicyNamespaceKey,
+  // 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;
 
   // A callback which receives boolean status of an operation.  If the operation
   // succeeded, |status| is true.
   typedef base::Callback<void(bool status)> StatusCallback;
 
   // Observer interface for state and policy changes.
   class POLICY_EXPORT Observer {
    public:
     virtual ~Observer();
@@ skipping 108 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;
   }
 
-  // FetchPolicy() calls will request this policy namespace.
-  void AddNamespaceToFetch(const PolicyNamespaceKey& policy_ns_key);
+  // FetchPolicy() calls will request this policy type.
+  // If |settings_entity_id| is empty then it won't be set in the
+  // PolicyFetchRequest.
+  void AddPolicyTypeToFetch(const std::string& policy_type,
+                            const std::string& settings_entity_id);
 
-  // FetchPolicy() calls won't request the given policy namespace anymore.
-  void RemoveNamespaceToFetch(const PolicyNamespaceKey& policy_ns_key);
+  // FetchPolicy() calls won't request the given policy type and optional
+  // |settings_entity_id| anymore.
+  void RemovePolicyTypeToFetch(const std::string& policy_type,
+                               const std::string& settings_entity_id);
 
   // Configures a set of device state keys to transfer to the server in the next
   // policy fetch. If the fetch is successful, the keys will be cleared so they
   // are only uploaded once.
   void SetStateKeysToUpload(const std::vector<std::string>& keys);
 
   // 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_; }
   const std::string& client_id() const { return client_id_; }
 
   // The device mode as received in the registration request.
   DeviceMode device_mode() const { return device_mode_; }
 
   // The policy responses as obtained by the last request to the cloud. These
   // policies haven't gone through verification, so their contents cannot be
   // trusted. Use CloudPolicyStore::policy() and CloudPolicyStore::policy_map()
   // instead for making policy decisions.
   const ResponseMap& responses() const {
     return responses_;
   }
 
-  // Returns the policy response for |policy_ns_key|, if found in |responses()|;
-  // otherwise returns NULL.
+  // Returns the policy response for the (|policy_type|, |settings_entity_id|)
+  // pair if found in |responses()|. Otherwise returns NULL.
   const enterprise_management::PolicyFetchResponse* GetPolicyFor(
-      const PolicyNamespaceKey& policy_ns_key) const;
+      const std::string& policy_type,
+      const std::string& settings_entity_id) const;
 
   DeviceManagementStatus status() const {
     return status_;
   }
 
   const std::string& robot_api_auth_code() const {
     return robot_api_auth_code_;
   }
 
   // Returns the invalidation version that was used for the last FetchPolicy.
   // Observers can call this method from their OnPolicyFetched method to
   // determine which at which invalidation version the policy was fetched.
   int64 fetched_invalidation_version() const {
     return fetched_invalidation_version_;
   }
 
   scoped_refptr<net::URLRequestContextGetter> GetRequestContext();
 
  protected:
-  // A set of PolicyNamespaceKeys to fetch.
-  typedef std::set<PolicyNamespaceKey> NamespaceSet;
+  // A set of (policy type, settings entity ID) pairs to fetch.
+  typedef std::set<std::pair<std::string, std::string>> TypeToFetchSet;

[Mattias Nissler (ping if slow), 2014/11/27 08:34:10]

nit: Let's rename this to PolicyTypeSet or something - that describes better
what the type is, which I think is more important than what it's used for.

[Joao da Silva, 2014/11/27 12:19:31]

Done.

 
   // Callback for retries of registration requests.
   void OnRetryRegister(DeviceManagementRequestJob* job);
 
   // Callback for registration requests.
   void OnRegisterCompleted(
       DeviceManagementStatus status,
       int net_error,
       const enterprise_management::DeviceManagementResponse& response);
 
@@ skipping 26 matching lines @@
   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 std::string verification_key_hash_;
   const UserAffiliation user_affiliation_;
-  NamespaceSet namespaces_to_fetch_;
+  TypeToFetchSet types_to_fetch_;
   std::vector<std::string> state_keys_to_upload_;
 
   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_;
@@ skipping 19 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_