Removed policy::PolicyNamespaceKey.

chrome/browser/chromeos/policy/device_local_account_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 "chrome/browser/chromeos/policy/device_local_account_policy_service.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 31 matching lines @@
 #include "policy/policy_constants.h"
 #include "policy/proto/device_management_backend.pb.h"
 #include "url/gurl.h"
 
 namespace em = enterprise_management;
 
 namespace policy {
 
 namespace {
 
-// Creates and initializes a cloud policy client. Returns NULL if the device
+// Creates and initializes a cloud policy client. Returns nullptr if the device
 // doesn't have credentials in device settings (i.e. is not
 // enterprise-enrolled).
 scoped_ptr<CloudPolicyClient> CreateClient(
     chromeos::DeviceSettingsService* device_settings_service,
     DeviceManagementService* device_management_service,
     scoped_refptr<net::URLRequestContextGetter> system_request_context) {
   const em::PolicyData* policy_data = device_settings_service->policy_data();
   if (!policy_data ||
       !policy_data->has_request_token() ||
       !policy_data->has_device_id() ||
       !device_management_service) {
     return scoped_ptr<CloudPolicyClient>();
   }
 
   scoped_refptr<net::URLRequestContextGetter> request_context =
       new SystemPolicyRequestContext(
           system_request_context, GetUserAgent());
 
-  scoped_ptr<CloudPolicyClient> client(
-      new CloudPolicyClient(std::string(), std::string(),
-                            kPolicyVerificationKeyHash,
-                            USER_AFFILIATION_MANAGED,
-                            NULL, device_management_service, request_context));
+  scoped_ptr<CloudPolicyClient> client(new CloudPolicyClient(
+      std::string(), std::string(), kPolicyVerificationKeyHash,
+      USER_AFFILIATION_MANAGED, nullptr, device_management_service,
+      request_context));
   client->SetupRegistration(policy_data->request_token(),
                             policy_data->device_id());
   return client.Pass();
 }
 
 // Get the subdirectory of the force-installed extension cache and the component
 // policy cache used for |account_id|.
 std::string GetCacheSubdirectoryForAccountID(const std::string& account_id) {
   return base::HexEncode(account_id.c_str(), account_id.size());
 }
@@ skipping 36 matching lines @@
     scoped_ptr<DeviceLocalAccountPolicyStore> store,
     scoped_refptr<DeviceLocalAccountExternalDataManager> external_data_manager,
     const base::Closure& policy_update_callback,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner)
     : account_id_(account.account_id),
       user_id_(account.user_id),
       component_policy_cache_path_(component_policy_cache_path),
       store_(store.Pass()),
       extension_tracker_(account, store_.get(), &schema_registry_),
       external_data_manager_(external_data_manager),
-      core_(PolicyNamespaceKey(dm_protocol::kChromePublicAccountPolicyType,
-                               store_->account_id()),
+      core_(dm_protocol::kChromePublicAccountPolicyType,
+            store_->account_id(),
             store_.get(),
             task_runner),
       policy_update_callback_(policy_update_callback) {
   base::FilePath cache_root_dir;
   CHECK(PathService::Get(chromeos::DIR_DEVICE_LOCAL_ACCOUNT_EXTENSIONS,
                          &cache_root_dir));
   extension_loader_ = new chromeos::DeviceLocalAccountExternalPolicyLoader(
       store_.get(),
       cache_root_dir.Append(
           GetCacheSubdirectoryForAccountID(account.account_id)));
   store_->AddObserver(this);
 
   // Unblock the |schema_registry_| so that the |component_policy_service_|
   // starts using it.
   schema_registry_.RegisterComponent(
-      PolicyNamespace(POLICY_DOMAIN_CHROME, ""),
+      PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()),
       g_browser_process->browser_policy_connector()->GetChromeSchema());
   schema_registry_.SetReady(POLICY_DOMAIN_CHROME);
   schema_registry_.SetReady(POLICY_DOMAIN_EXTENSIONS);
 }
 
 DeviceLocalAccountPolicyBroker::~DeviceLocalAccountPolicyBroker() {
   store_->RemoveObserver(this);
-  external_data_manager_->SetPolicyStore(NULL);
+  external_data_manager_->SetPolicyStore(nullptr);
   external_data_manager_->Disconnect();
 }
 
 void DeviceLocalAccountPolicyBroker::Initialize() {
   store_->Load();
 }
 
 void DeviceLocalAccountPolicyBroker::ConnectIfPossible(
     chromeos::DeviceSettingsService* device_settings_service,
     DeviceManagementService* device_management_service,
@@ skipping 77 matching lines @@
     chromeos::CrosSettings* cros_settings,
     scoped_refptr<base::SequencedTaskRunner> store_background_task_runner,
     scoped_refptr<base::SequencedTaskRunner> extension_cache_task_runner,
     scoped_refptr<base::SequencedTaskRunner>
         external_data_service_backend_task_runner,
     scoped_refptr<base::SequencedTaskRunner> io_task_runner,
     scoped_refptr<net::URLRequestContextGetter> request_context)
     : session_manager_client_(session_manager_client),
       device_settings_service_(device_settings_service),
       cros_settings_(cros_settings),
-      device_management_service_(NULL),
+      device_management_service_(nullptr),
       waiting_for_cros_settings_(false),
       orphan_extension_cache_deletion_state_(NOT_STARTED),
       store_background_task_runner_(store_background_task_runner),
       extension_cache_task_runner_(extension_cache_task_runner),
       request_context_(request_context),
       local_accounts_subscription_(cros_settings_->AddSettingsObserver(
           chromeos::kAccountsPrefDeviceLocalAccounts,
           base::Bind(&DeviceLocalAccountPolicyService::
                          UpdateAccountListIfNonePending,
                      base::Unretained(this)))),
       weak_factory_(this) {
   CHECK(PathService::Get(chromeos::DIR_DEVICE_LOCAL_ACCOUNT_COMPONENT_POLICY,
                          &component_policy_cache_root_));
   external_data_service_.reset(new DeviceLocalAccountExternalDataService(
       this,
       external_data_service_backend_task_runner,
       io_task_runner));
   UpdateAccountList();
 }
 
 DeviceLocalAccountPolicyService::~DeviceLocalAccountPolicyService() {
   DCHECK(!request_context_.get());
   DCHECK(policy_brokers_.empty());
 }
 
 void DeviceLocalAccountPolicyService::Shutdown() {
-  device_management_service_ = NULL;
-  request_context_ = NULL;
+  device_management_service_ = nullptr;
+  request_context_ = nullptr;
   DeleteBrokers(&policy_brokers_);
 }
 
 void DeviceLocalAccountPolicyService::Connect(
     DeviceManagementService* device_management_service) {
   DCHECK(!device_management_service_);
   device_management_service_ = device_management_service;
 
   // Connect the brokers.
   for (PolicyBrokerMap::iterator it(policy_brokers_.begin());
        it != policy_brokers_.end(); ++it) {
     it->second->ConnectIfPossible(device_settings_service_,
                                   device_management_service_,
                                   request_context_);
   }
 }
 
 DeviceLocalAccountPolicyBroker*
     DeviceLocalAccountPolicyService::GetBrokerForUser(
         const std::string& user_id) {
   PolicyBrokerMap::iterator entry = policy_brokers_.find(user_id);
   if (entry == policy_brokers_.end())
-    return NULL;
+    return nullptr;
 
   return entry->second;
 }
 
 bool DeviceLocalAccountPolicyService::IsPolicyAvailableForUser(
     const std::string& user_id) {
   DeviceLocalAccountPolicyBroker* broker = GetBrokerForUser(user_id);
   return broker && broker->core()->store()->is_managed();
 }
 
@@ skipping 234 matching lines @@
 }
 
 DeviceLocalAccountPolicyBroker*
     DeviceLocalAccountPolicyService::GetBrokerForStore(
         CloudPolicyStore* store) {
   for (PolicyBrokerMap::iterator it(policy_brokers_.begin());
        it != policy_brokers_.end(); ++it) {
     if (it->second->core()->store() == store)
       return it->second;
   }
-  return NULL;
+  return nullptr;
 }
 
 void DeviceLocalAccountPolicyService::NotifyPolicyUpdated(
     const std::string& user_id) {
   FOR_EACH_OBSERVER(Observer, observers_, OnPolicyUpdated(user_id));
 }
 
 }  // namespace policy