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

chrome/browser/chromeos/settings/device_settings_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/settings/device_settings_provider.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 144 matching lines @@
       !policy.has_show_user_names() ||
       !policy.show_user_names().has_show_user_names() ||
       policy.show_user_names().show_user_names());
 
   new_values_cache->SetBoolean(
       kAccountsPrefEphemeralUsersEnabled,
       policy.has_ephemeral_users_enabled() &&
       policy.ephemeral_users_enabled().has_ephemeral_users_enabled() &&
       policy.ephemeral_users_enabled().ephemeral_users_enabled());
 
-  scoped_ptr<base::ListValue> list(new base::ListValue());
+  std::unique_ptr<base::ListValue> list(new base::ListValue());
   const em::UserWhitelistProto& whitelist_proto = policy.user_whitelist();
   const RepeatedPtrField<std::string>& whitelist =
       whitelist_proto.user_whitelist();
   for (RepeatedPtrField<std::string>::const_iterator it = whitelist.begin();
        it != whitelist.end(); ++it) {
     list->Append(new base::StringValue(*it));
   }
   new_values_cache->SetValue(kAccountsPrefUsers, std::move(list));
 
-  scoped_ptr<base::ListValue> account_list(new base::ListValue());
+  std::unique_ptr<base::ListValue> account_list(new base::ListValue());
   const em::DeviceLocalAccountsProto device_local_accounts_proto =
       policy.device_local_accounts();
   const RepeatedPtrField<em::DeviceLocalAccountInfoProto>& accounts =
       device_local_accounts_proto.account();
   RepeatedPtrField<em::DeviceLocalAccountInfoProto>::const_iterator entry;
   for (entry = accounts.begin(); entry != accounts.end(); ++entry) {
-    scoped_ptr<base::DictionaryValue> entry_dict(new base::DictionaryValue());
+    std::unique_ptr<base::DictionaryValue> entry_dict(
+        new base::DictionaryValue());
     if (entry->has_type()) {
       if (entry->has_account_id()) {
         entry_dict->SetStringWithoutPathExpansion(
             kAccountsPrefDeviceLocalAccountsKeyId, entry->account_id());
       }
       entry_dict->SetIntegerWithoutPathExpansion(
           kAccountsPrefDeviceLocalAccountsKeyType, entry->type());
       if (entry->kiosk_app().has_app_id()) {
         entry_dict->SetStringWithoutPathExpansion(
             kAccountsPrefDeviceLocalAccountsKeyKioskAppId,
@@ skipping 32 matching lines @@
   }
 
   new_values_cache->SetBoolean(
       kAccountsPrefDeviceLocalAccountAutoLoginBailoutEnabled,
       policy.device_local_accounts().enable_auto_login_bailout());
   new_values_cache->SetBoolean(
       kAccountsPrefDeviceLocalAccountPromptForNetworkWhenOffline,
       policy.device_local_accounts().prompt_for_network_when_offline());
 
   if (policy.has_start_up_flags()) {
-    scoped_ptr<base::ListValue> list(new base::ListValue());
+    std::unique_ptr<base::ListValue> list(new base::ListValue());
     const em::StartUpFlagsProto& flags_proto = policy.start_up_flags();
     const RepeatedPtrField<std::string>& flags = flags_proto.flags();
     for (RepeatedPtrField<std::string>::const_iterator it = flags.begin();
          it != flags.end(); ++it) {
       list->Append(new base::StringValue(*it));
     }
     new_values_cache->SetValue(kStartUpFlags, std::move(list));
   }
 
   if (policy.has_saml_settings()) {
@@ skipping 41 matching lines @@
     PrefValueMap* new_values_cache) {
   if (policy.has_auto_update_settings()) {
     const em::AutoUpdateSettingsProto& au_settings_proto =
         policy.auto_update_settings();
     if (au_settings_proto.has_update_disabled()) {
       new_values_cache->SetBoolean(kUpdateDisabled,
                                    au_settings_proto.update_disabled());
     }
     const RepeatedField<int>& allowed_connection_types =
         au_settings_proto.allowed_connection_types();
-    scoped_ptr<base::ListValue> list(new base::ListValue());
+    std::unique_ptr<base::ListValue> list(new base::ListValue());
     for (RepeatedField<int>::const_iterator i(allowed_connection_types.begin());
          i != allowed_connection_types.end(); ++i) {
       list->Append(new base::FundamentalValue(*i));
     }
     new_values_cache->SetValue(kAllowedConnectionTypesForUpdate,
                                std::move(list));
   }
 }
 
 void DecodeReportingPolicies(
@@ skipping 288 matching lines @@
     trusted_status_ = TEMPORARILY_UNTRUSTED;
     // Apply the locally-accumulated device settings on top of the initial
     // settings from the service and write back the result.
     if (device_settings_service_->device_settings()) {
       em::ChromeDeviceSettingsProto new_settings(
           *device_settings_service_->device_settings());
       new_settings.MergeFrom(device_settings_);
       device_settings_.Swap(&new_settings);
     }
 
-    scoped_ptr<em::PolicyData> policy(new em::PolicyData());
+    std::unique_ptr<em::PolicyData> policy(new em::PolicyData());
     policy->set_username(device_settings_service_->GetUsername());
     CHECK(device_settings_.SerializeToString(policy->mutable_policy_value()));
     if (!device_settings_service_->GetOwnerSettingsService()
              ->CommitTentativeDeviceSettings(std::move(policy))) {
       LOG(ERROR) << "Can't store policy";
     }
   }
 
   ownership_status_ = new_ownership_status;
 }
@@ skipping 195 matching lines @@
   // Notify the observers we are done.
   std::vector<base::Closure> callbacks;
   callbacks.swap(callbacks_);
   for (size_t i = 0; i < callbacks.size(); ++i)
     callbacks[i].Run();
 
   return settings_loaded;
 }
 
 }  // namespace chromeos