Removed policy::PolicyNamespaceKey.

chrome/browser/chromeos/policy/enrollment_handler_chromeos.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 "chrome/browser/chromeos/policy/enrollment_handler_chromeos.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 58 matching lines @@
       device_mode_(DEVICE_MODE_NOT_SET),
       enrollment_step_(STEP_PENDING),
       lockbox_init_duration_(0),
       weak_ptr_factory_(this) {
   CHECK(!client_->is_registered());
   CHECK_EQ(DM_STATUS_SUCCESS, client_->status());
   CHECK(management_mode_ == em::PolicyData::ENTERPRISE_MANAGED ||
         management_mode_ == em::PolicyData::CONSUMER_MANAGED);
   store_->AddObserver(this);
   client_->AddObserver(this);
-  client_->AddNamespaceToFetch(PolicyNamespaceKey(
-      dm_protocol::kChromeDevicePolicyType, std::string()));
+  client_->AddPolicyTypeToFetch(dm_protocol::kChromeDevicePolicyType,
+                                std::string());
 }
 
 EnrollmentHandlerChromeOS::~EnrollmentHandlerChromeOS() {
   Stop();
   store_->RemoveObserver(this);
 }
 
 void EnrollmentHandlerChromeOS::StartEnrollment() {
   CHECK_EQ(STEP_PENDING, enrollment_step_);
   enrollment_step_ = STEP_STATE_KEYS;
   state_keys_broker_->RequestStateKeys(
       base::Bind(&EnrollmentHandlerChromeOS::HandleStateKeysResult,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 scoped_ptr<CloudPolicyClient> EnrollmentHandlerChromeOS::ReleaseClient() {
   Stop();
   return client_.Pass();
 }
 
 void EnrollmentHandlerChromeOS::OnPolicyFetched(CloudPolicyClient* client) {
   DCHECK_EQ(client_.get(), client);
   CHECK_EQ(STEP_POLICY_FETCH, enrollment_step_);
 
   enrollment_step_ = STEP_VALIDATION;
 
   // Validate the policy.
   const em::PolicyFetchResponse* policy = client_->GetPolicyFor(
-      PolicyNamespaceKey(dm_protocol::kChromeDevicePolicyType, std::string()));
+      dm_protocol::kChromeDevicePolicyType, std::string());
   if (!policy) {
     ReportResult(EnrollmentStatus::ForFetchError(
         DM_STATUS_RESPONSE_DECODING_ERROR));
     return;
   }
 
   scoped_ptr<DeviceCloudPolicyValidator> validator(
       DeviceCloudPolicyValidator::Create(
           scoped_ptr<em::PolicyFetchResponse>(
               new em::PolicyFetchResponse(*policy)),
@@ skipping 14 matching lines @@
   validator->ValidatePolicyType(dm_protocol::kChromeDevicePolicyType);
   validator->ValidatePayload();
   if (management_mode_ == em::PolicyData::CONSUMER_MANAGED) {
     // For consumer-managed devices, although we don't store the policy, we
     // still need to verify its integrity since we use the request token in it.
     // The consumer device management server does not have the verification
     // key, and we need to skip checking on that by passing an empty key to
     // ValidateInitialKey(). ValidateInitialKey() still checks that the policy
     // data is correctly signed by the new public key when the verification key
     // is empty.
-    validator->ValidateInitialKey("", "");
+    validator->ValidateInitialKey(std::string(), std::string());
   } else {
     // If |domain| is empty here, the policy validation code will just use the
     // domain from the username field in the policy itself to do key validation.
     // TODO(mnissler): Plumb the enrolling user's username into this object so
     // we can validate the username on the resulting policy, and use the domain
     // from that username to validate the key below (http://crbug.com/343074).
     validator->ValidateInitialKey(GetPolicyVerificationKey(), domain);
   }
   validator.release()->StartValidation(
       base::Bind(&EnrollmentHandlerChromeOS::HandlePolicyValidationResult,
@@ skipping 299 matching lines @@
                  << ", validation: " << status.validation_status()
                  << ", store: " << status.store_status()
                  << ", lock: " << status.lock_status();
   }
 
   if (!callback.is_null())
     callback.Run(status);
 }
 
 }  // namespace policy