Removed policy::PolicyNamespaceKey.

components/policy/core/common/cloud/cloud_policy_service.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_service.h"
 
 #include "base/callback.h"
 #include "policy/proto/device_management_backend.pb.h"
 
 namespace em = enterprise_management;
 
 namespace policy {
 
-CloudPolicyService::CloudPolicyService(const PolicyNamespaceKey& policy_ns_key,
+CloudPolicyService::CloudPolicyService(const std::string& policy_type,
+                                       const std::string& settings_entity_id,
                                        CloudPolicyClient* client,
                                        CloudPolicyStore* store)
-    : policy_ns_key_(policy_ns_key),
+    : policy_type_(policy_type),
+      settings_entity_id_(settings_entity_id),
       client_(client),
       store_(store),
       refresh_state_(REFRESH_NONE),
       initialization_complete_(false) {
-  client_->AddNamespaceToFetch(policy_ns_key_);
+  client_->AddPolicyTypeToFetch(policy_type_, settings_entity_id_);
   client_->AddObserver(this);
   store_->AddObserver(this);
 
   // Make sure we initialize |client_| from the policy data that might be
   // already present in |store_|.
   OnStoreLoaded(store_);
 }
 
 CloudPolicyService::~CloudPolicyService() {
-  client_->RemoveNamespaceToFetch(policy_ns_key_);
+  client_->RemovePolicyTypeToFetch(policy_type_, settings_entity_id_);
   client_->RemoveObserver(this);
   store_->RemoveObserver(this);
 }
 
 std::string CloudPolicyService::ManagedBy() const {
   const em::PolicyData* policy = store_->policy();
   if (policy) {
     std::string username = policy->username();
     std::size_t pos = username.find('@');
     if (pos != std::string::npos)
@@ skipping 14 matching lines @@
   refresh_state_ = REFRESH_POLICY_FETCH;
   client_->FetchPolicy();
 }
 
 void CloudPolicyService::OnPolicyFetched(CloudPolicyClient* client) {
   if (client_->status() != DM_STATUS_SUCCESS) {
     RefreshCompleted(false);
     return;
   }
 
-  const em::PolicyFetchResponse* policy = client_->GetPolicyFor(policy_ns_key_);
+  const em::PolicyFetchResponse* policy =
+      client_->GetPolicyFor(policy_type_, settings_entity_id_);
   if (policy) {
     if (refresh_state_ != REFRESH_NONE)
       refresh_state_ = REFRESH_POLICY_STORE;
     store_->Store(*policy, client->fetched_invalidation_version());
   } else {
     RefreshCompleted(false);
   }
 }
 
 void CloudPolicyService::OnRegistrationStateChanged(CloudPolicyClient* client) {
@@ skipping 73 matching lines @@
 
 void CloudPolicyService::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void CloudPolicyService::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 }  // namespace policy