Removed policy::PolicyNamespaceKey.

components/policy/core/common/cloud/cloud_policy_client.cc

 // 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.
 
 #include "components/policy/core/common/cloud/cloud_policy_client.h"
 
 #include "base/bind.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 47 matching lines @@
     : machine_id_(machine_id),
       machine_model_(machine_model),
       verification_key_hash_(verification_key_hash),
       user_affiliation_(user_affiliation),
       device_mode_(DEVICE_MODE_NOT_SET),
       submit_machine_id_(false),
       public_key_version_(-1),
       public_key_version_valid_(false),
       invalidation_version_(0),
       fetched_invalidation_version_(0),
-      service_(service),                  // Can be NULL for unit tests.
-      status_provider_(status_provider),  // Can be NULL for unit tests.
+      service_(service),                  // Can be null for unit tests.
+      status_provider_(status_provider),  // Can be null for unit tests.
       status_(DM_STATUS_SUCCESS),
       request_context_(request_context) {
 }
 
 CloudPolicyClient::~CloudPolicyClient() {
   STLDeleteValues(&responses_);
 }
 
 void CloudPolicyClient::SetupRegistration(const std::string& dm_token,
                                           const std::string& client_id) {
@@ skipping 59 matching lines @@
 
 void CloudPolicyClient::SetInvalidationInfo(
     int64 version,
     const std::string& payload) {
   invalidation_version_ = version;
   invalidation_payload_ = payload;
 }
 
 void CloudPolicyClient::FetchPolicy() {
   CHECK(is_registered());
-  CHECK(!namespaces_to_fetch_.empty());
+  CHECK(!types_to_fetch_.empty());
 
   request_job_.reset(
       service_->CreateJob(DeviceManagementRequestJob::TYPE_POLICY_FETCH,
                           GetRequestContext()));
   request_job_->SetDMToken(dm_token_);
   request_job_->SetClientID(client_id_);
   request_job_->SetUserAffiliation(user_affiliation_);
 
   em::DeviceManagementRequest* request = request_job_->GetRequest();
 
   // Build policy fetch requests.
   em::DevicePolicyRequest* policy_request = request->mutable_policy_request();
-  for (NamespaceSet::iterator it = namespaces_to_fetch_.begin();
-       it != namespaces_to_fetch_.end(); ++it) {
+  for (const auto& type_to_fetch : types_to_fetch_) {
     em::PolicyFetchRequest* fetch_request = policy_request->add_request();
-    fetch_request->set_policy_type(it->first);
-    if (!it->second.empty())
-      fetch_request->set_settings_entity_id(it->second);
+    fetch_request->set_policy_type(type_to_fetch.first);
+    if (!type_to_fetch.second.empty())
+      fetch_request->set_settings_entity_id(type_to_fetch.second);
 
     // Request signed policy blobs to help prevent tampering on the client.
     fetch_request->set_signature_type(em::PolicyFetchRequest::SHA1_RSA);
     if (public_key_version_valid_)
       fetch_request->set_public_key_version(public_key_version_);
 
     if (!verification_key_hash_.empty())
       fetch_request->set_verification_key_hash(verification_key_hash_);
 
     // These fields are included only in requests for chrome policy.
-    if (IsChromePolicy(it->first)) {
+    if (IsChromePolicy(type_to_fetch.first)) {

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

Side note: We may eventually change this to not hardcode the if-is-chrome-policy
here, but keep the necessary fields in a map keyed by the policy type.

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

Ack

       if (submit_machine_id_ && !machine_id_.empty())
         fetch_request->set_machine_id(machine_id_);
       if (!last_policy_timestamp_.is_null()) {
         base::TimeDelta timestamp(
             last_policy_timestamp_ - base::Time::UnixEpoch());
         fetch_request->set_timestamp(timestamp.InMilliseconds());
       }
       if (!invalidation_payload_.empty()) {
         fetch_request->set_invalidation_version(invalidation_version_);
         fetch_request->set_invalidation_payload(invalidation_payload_);
@@ skipping 92 matching lines @@
 }
 
 void CloudPolicyClient::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void CloudPolicyClient::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
-void CloudPolicyClient::AddNamespaceToFetch(const PolicyNamespaceKey& key) {
-  namespaces_to_fetch_.insert(key);
+void CloudPolicyClient::AddPolicyTypeToFetch(
+    const std::string& policy_type,
+    const std::string& settings_entity_id) {
+  types_to_fetch_.insert(std::make_pair(policy_type, settings_entity_id));
 }
 
-void CloudPolicyClient::RemoveNamespaceToFetch(const PolicyNamespaceKey& key) {
-  namespaces_to_fetch_.erase(key);
+void CloudPolicyClient::RemovePolicyTypeToFetch(
+    const std::string& policy_type,
+    const std::string& settings_entity_id) {
+  types_to_fetch_.erase(std::make_pair(policy_type, settings_entity_id));
 }
 
 void CloudPolicyClient::SetStateKeysToUpload(
     const std::vector<std::string>& keys) {
   state_keys_to_upload_ = keys;
 }
 
 const em::PolicyFetchResponse* CloudPolicyClient::GetPolicyFor(
-    const PolicyNamespaceKey& key) const {
-  ResponseMap::const_iterator it = responses_.find(key);
-  return it == responses_.end() ? NULL : it->second;
+    const std::string& policy_type,
+    const std::string& settings_entity_id) const {
+  ResponseMap::const_iterator it =
+      responses_.find(std::make_pair(policy_type, settings_entity_id));
+  return it == responses_.end() ? nullptr : it->second;
 }
 
 scoped_refptr<net::URLRequestContextGetter>
 CloudPolicyClient::GetRequestContext() {
   return request_context_;
 }
 
 void CloudPolicyClient::OnRetryRegister(DeviceManagementRequestJob* job) {
   DCHECK_EQ(request_job_.get(), job);
   // If the initial request managed to get to the server but the response didn't
@@ skipping 80 matching lines @@
       if (!policy_data.ParseFromString(response.policy_data()) ||
           !policy_data.IsInitialized() ||
           !policy_data.has_policy_type()) {
         LOG(WARNING) << "Invalid PolicyData received, ignoring";
         continue;
       }
       const std::string& type = policy_data.policy_type();
       std::string entity_id;
       if (policy_data.has_settings_entity_id())
         entity_id = policy_data.settings_entity_id();
-      PolicyNamespaceKey key(type, entity_id);
+      std::pair<std::string, std::string> key(type, entity_id);
       if (ContainsKey(responses_, key)) {
         LOG(WARNING) << "Duplicate PolicyFetchResponse for type: "
             << type << ", entity: " << entity_id << ", ignoring";
         continue;
       }
       responses_[key] = new em::PolicyFetchResponse(response);
     }
     if (status_provider_)
       status_provider_->OnSubmittedSuccessfully();
     state_keys_to_upload_.clear();
@@ skipping 51 matching lines @@
 
 void CloudPolicyClient::NotifyRobotAuthCodesFetched() {
   FOR_EACH_OBSERVER(Observer, observers_, OnRobotAuthCodesFetched(this));
 }
 
 void CloudPolicyClient::NotifyClientError() {
   FOR_EACH_OBSERVER(Observer, observers_, OnClientError(this));
 }
 
 }  // namespace policy