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

chrome/browser/chromeos/policy/device_policy_decoder_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/device_policy_decoder_chromeos.h"
 
 #include <limits>
 #include <string>
 
 #include "base/callback.h"
@@ skipping 20 matching lines @@
 using google::protobuf::RepeatedPtrField;
 
 namespace em = enterprise_management;
 
 namespace policy {
 
 namespace {
 
 // Decodes a protobuf integer to an IntegerValue. Returns NULL in case the input
 // value is out of bounds.
-scoped_ptr<base::Value> DecodeIntegerValue(google::protobuf::int64 value) {
+std::unique_ptr<base::Value> DecodeIntegerValue(google::protobuf::int64 value) {
   if (value < std::numeric_limits<int>::min() ||
       value > std::numeric_limits<int>::max()) {
     LOG(WARNING) << "Integer value " << value
                  << " out of numeric limits, ignoring.";
-    return scoped_ptr<base::Value>();
+    return std::unique_ptr<base::Value>();
   }
 
-  return scoped_ptr<base::Value>(
+  return std::unique_ptr<base::Value>(
       new base::FundamentalValue(static_cast<int>(value)));
 }
 
 // Decodes a JSON string to a base::Value, and drops unknown properties
 // according to a policy schema. |policy_name| is the name of a policy schema
 // defined in policy_templates.json. Returns NULL in case the input is not a
 // valid JSON string.
-scoped_ptr<base::Value> DecodeJsonStringAndDropUnknownBySchema(
+std::unique_ptr<base::Value> DecodeJsonStringAndDropUnknownBySchema(
     const std::string& json_string,
     const std::string& policy_name) {
   std::string error;
-  scoped_ptr<base::Value> root = base::JSONReader::ReadAndReturnError(
+  std::unique_ptr<base::Value> root = base::JSONReader::ReadAndReturnError(
       json_string, base::JSON_ALLOW_TRAILING_COMMAS, NULL, &error);
 
   if (!root) {
     LOG(WARNING) << "Invalid JSON string: " << error << ", ignoring.";
-    return scoped_ptr<base::Value>();
+    return std::unique_ptr<base::Value>();
   }
 
   const Schema& schema = g_browser_process
                              ->browser_policy_connector()
                              ->GetChromeSchema()
                              .GetKnownProperty(policy_name);
 
   if (schema.valid()) {
     std::string error_path;
     bool changed = false;
 
     if (!schema.Normalize(root.get(), SCHEMA_ALLOW_UNKNOWN, &error_path, &error,
                           &changed)) {
       LOG(WARNING) << "Invalid policy value for " << policy_name << ": "
                    << error << " at " << error_path << ".";
-      return scoped_ptr<base::Value>();
+      return std::unique_ptr<base::Value>();
     }
 
     if (changed) {
       LOG(WARNING) << "Some properties in " << policy_name
                    << " were dropped: " << error << " at " << error_path << ".";
     }
   } else {
     LOG(WARNING) << "Unknown or invalid policy schema for " << policy_name
                  << ".";
-    return scoped_ptr<base::Value>();
+    return std::unique_ptr<base::Value>();
   }
 
   return root;
 }
 
 base::Value* DecodeConnectionType(int value) {
   static const char* const kConnectionTypes[] = {
     shill::kTypeEthernet,
     shill::kTypeWifi,
     shill::kTypeWimax,
@@ skipping 88 matching lines @@
                         container.ephemeral_users_enabled()),
                     NULL);
     }
   }
 
   if (policy.has_device_local_accounts()) {
     const em::DeviceLocalAccountsProto& container(
         policy.device_local_accounts());
     const RepeatedPtrField<em::DeviceLocalAccountInfoProto>& accounts =
         container.account();
-    scoped_ptr<base::ListValue> account_list(new base::ListValue());
+    std::unique_ptr<base::ListValue> account_list(new base::ListValue());
     RepeatedPtrField<em::DeviceLocalAccountInfoProto>::const_iterator entry;
     for (entry = accounts.begin(); entry != accounts.end(); ++entry) {
-      scoped_ptr<base::DictionaryValue> entry_dict(
+      std::unique_ptr<base::DictionaryValue> entry_dict(
           new base::DictionaryValue());
       if (entry->has_type()) {
         if (entry->has_account_id()) {
           entry_dict->SetStringWithoutPathExpansion(
               chromeos::kAccountsPrefDeviceLocalAccountsKeyId,
               entry->account_id());
         }
         entry_dict->SetIntegerWithoutPathExpansion(
             chromeos::kAccountsPrefDeviceLocalAccountsKeyType, entry->type());
         if (entry->kiosk_app().has_app_id()) {
@@ skipping 486 matching lines @@
       policies->Set(key::kSystemTimezone,
                     POLICY_LEVEL_MANDATORY,
                     POLICY_SCOPE_MACHINE,
                     POLICY_SOURCE_CLOUD,
                     new base::StringValue(
                         policy.system_timezone().timezone()),
                     NULL);
     }
 
     if (policy.system_timezone().has_timezone_detection_type()) {
-      scoped_ptr<base::Value> value(DecodeIntegerValue(
+      std::unique_ptr<base::Value> value(DecodeIntegerValue(
           policy.system_timezone().timezone_detection_type()));
       if (value) {
         policies->Set(key::kSystemTimezoneAutomaticDetection,
                       POLICY_LEVEL_MANDATORY,
                       POLICY_SCOPE_MACHINE,
                       POLICY_SOURCE_CLOUD,
                       value.release(),
                       nullptr);
       }
     }
@@ skipping 85 matching lines @@
           new base::FundamentalValue(
               policy.attestation_settings().content_protection_enabled()),
           NULL);
     }
   }
 
   if (policy.has_login_screen_power_management()) {
     const em::LoginScreenPowerManagementProto& container(
         policy.login_screen_power_management());
     if (container.has_login_screen_power_management()) {
-      scoped_ptr<base::Value> decoded_json;
+      std::unique_ptr<base::Value> decoded_json;
       decoded_json = DecodeJsonStringAndDropUnknownBySchema(
           container.login_screen_power_management(),
           key::kDeviceLoginScreenPowerManagement);
       if (decoded_json) {
         policies->Set(key::kDeviceLoginScreenPowerManagement,
                       POLICY_LEVEL_MANDATORY,
                       POLICY_SCOPE_MACHINE,
                       POLICY_SOURCE_CLOUD,
                       decoded_json.release(),
                       NULL);
@@ skipping 94 matching lines @@
   // Decode the various groups of policies.
   DecodeLoginPolicies(policy, policies);
   DecodeNetworkPolicies(policy, policies);
   DecodeReportingPolicies(policy, policies);
   DecodeAutoUpdatePolicies(policy, policies);
   DecodeAccessibilityPolicies(policy, policies);
   DecodeGenericPolicies(policy, policies);
 }
 
 }  // namespace policy