Convert //chrome/browser/chromeos from scoped_ptr to std::unique_ptr

chrome/browser/chromeos/policy/device_local_account_policy_provider.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_provider.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/policy/device_local_account_external_data_manager.h"
 #include "chromeos/dbus/power_policy_controller.h"
 #include "components/policy/core/common/cloud/cloud_policy_core.h"
 #include "components/policy/core/common/cloud/cloud_policy_service.h"
 #include "components/policy/core/common/cloud/component_cloud_policy_service.h"
 #include "components/policy/core/common/policy_bundle.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/policy/core/common/policy_namespace.h"
 #include "components/policy/core/common/policy_types.h"
 #include "policy/policy_constants.h"
 
 namespace policy {
 
 DeviceLocalAccountPolicyProvider::DeviceLocalAccountPolicyProvider(
     const std::string& user_id,
     DeviceLocalAccountPolicyService* service,
-    scoped_ptr<PolicyMap> chrome_policy_overrides)
+    std::unique_ptr<PolicyMap> chrome_policy_overrides)
     : user_id_(user_id),
       service_(service),
       chrome_policy_overrides_(std::move(chrome_policy_overrides)),
       store_initialized_(false),
       waiting_for_policy_refresh_(false),
       weak_factory_(this) {
   service_->AddObserver(this);
   UpdateFromBroker();
 }
 
 DeviceLocalAccountPolicyProvider::~DeviceLocalAccountPolicyProvider() {
   service_->RemoveObserver(this);
 }
 
 // static
-scoped_ptr<DeviceLocalAccountPolicyProvider>
+std::unique_ptr<DeviceLocalAccountPolicyProvider>
 DeviceLocalAccountPolicyProvider::Create(
     const std::string& user_id,
     DeviceLocalAccountPolicyService* device_local_account_policy_service) {
   DeviceLocalAccount::Type type;
   if (!device_local_account_policy_service ||
       !IsDeviceLocalAccountUser(user_id, &type)) {
-    return scoped_ptr<DeviceLocalAccountPolicyProvider>();
+    return std::unique_ptr<DeviceLocalAccountPolicyProvider>();
   }
 
-  scoped_ptr<PolicyMap> chrome_policy_overrides;
+  std::unique_ptr<PolicyMap> chrome_policy_overrides;
   if (type == DeviceLocalAccount::TYPE_PUBLIC_SESSION) {
     chrome_policy_overrides.reset(new PolicyMap());
 
     // Exit the session when the lid is closed. The default behavior is to
     // suspend while leaving the session running, which is not desirable for
     // public sessions.
     chrome_policy_overrides->Set(
         key::kLidCloseAction,
         POLICY_LEVEL_MANDATORY,
         POLICY_SCOPE_MACHINE,
@@ skipping 23 matching lines @@
     // shelf cannot be hidden by entering fullscreen mode.
     chrome_policy_overrides->Set(
         key::kFullscreenAllowed,
         POLICY_LEVEL_MANDATORY,
         POLICY_SCOPE_MACHINE,
         POLICY_SOURCE_PUBLIC_SESSION_OVERRIDE,
         new base::FundamentalValue(false),
         NULL);
   }
 
-  scoped_ptr<DeviceLocalAccountPolicyProvider> provider(
+  std::unique_ptr<DeviceLocalAccountPolicyProvider> provider(
       new DeviceLocalAccountPolicyProvider(user_id,
                                            device_local_account_policy_service,
                                            std::move(chrome_policy_overrides)));
   return provider;
 }
 
 bool DeviceLocalAccountPolicyProvider::IsInitializationComplete(
     PolicyDomain domain) const {
   if (domain == POLICY_DOMAIN_CHROME)
     return store_initialized_;
@@ skipping 31 matching lines @@
   return service_->GetBrokerForUser(user_id_);
 }
 
 void DeviceLocalAccountPolicyProvider::ReportPolicyRefresh(bool success) {
   waiting_for_policy_refresh_ = false;
   UpdateFromBroker();
 }
 
 void DeviceLocalAccountPolicyProvider::UpdateFromBroker() {
   DeviceLocalAccountPolicyBroker* broker = GetBroker();
-  scoped_ptr<PolicyBundle> bundle(new PolicyBundle());
+  std::unique_ptr<PolicyBundle> bundle(new PolicyBundle());
   if (broker) {
     store_initialized_ |= broker->core()->store()->is_initialized();
     if (!waiting_for_policy_refresh_) {
       // Copy policy from the broker.
       bundle->Get(PolicyNamespace(POLICY_DOMAIN_CHROME, std::string()))
           .CopyFrom(broker->core()->store()->policy_map());
       external_data_manager_ = broker->external_data_manager();
 
       if (broker->component_policy_service())
         bundle->MergeFrom(broker->component_policy_service()->policy());
@@ skipping 22 matching lines @@
                         entry.source,
                         entry.value->DeepCopy(),
                         nullptr);
     }
   }
 
   UpdatePolicy(std::move(bundle));
 }
 
 }  // namespace policy