Convert //extensions/{common,shell} from scoped_ptr to std::unique_ptr

extensions/common/extension_api.cc

 // Copyright 2013 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 "extensions/common/extension_api.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <string>
@@ skipping 27 matching lines @@
 const char* kChildKinds[] = {
   "functions",
   "events"
 };
 
 base::StringPiece ReadFromResource(int resource_id) {
   return ResourceBundle::GetSharedInstance().GetRawDataResource(
       resource_id);
 }
 
-scoped_ptr<base::ListValue> LoadSchemaList(const std::string& name,
-                                           const base::StringPiece& schema) {
+std::unique_ptr<base::ListValue> LoadSchemaList(
+    const std::string& name,
+    const base::StringPiece& schema) {
   std::string error_message;
-  scoped_ptr<base::Value> result(
-      base::JSONReader::ReadAndReturnError(
-          schema,
-          base::JSON_PARSE_RFC | base::JSON_DETACHABLE_CHILDREN,  // options
-          NULL,  // error code
-          &error_message));
+  std::unique_ptr<base::Value> result(base::JSONReader::ReadAndReturnError(
+      schema,
+      base::JSON_PARSE_RFC | base::JSON_DETACHABLE_CHILDREN,  // options
+      NULL,                                                   // error code
+      &error_message));
 
   // Tracking down http://crbug.com/121424
   char buf[128];
   base::snprintf(buf, arraysize(buf), "%s: (%d) '%s'",
       name.c_str(),
       result.get() ? result->GetType() : -1,
       error_message.c_str());
 
   CHECK(result.get()) << error_message << " for schema " << schema;
   CHECK(result->IsType(base::Value::TYPE_LIST)) << " for schema " << schema;
@@ skipping 28 matching lines @@
       return child_node;
   }
 
   return NULL;
 }
 
 struct Static {
   Static()
       : api(ExtensionAPI::CreateWithDefaultConfiguration()) {
   }
-  scoped_ptr<ExtensionAPI> api;
+  std::unique_ptr<ExtensionAPI> api;
 };
 
 base::LazyInstance<Static> g_lazy_instance = LAZY_INSTANCE_INITIALIZER;
 
 // May override |g_lazy_instance| for a test.
 ExtensionAPI* g_shared_instance_for_test = NULL;
 
 // If it exists and does not already specify a namespace, then the value stored
 // with key |key| in |schema| will be updated to |schema_namespace| + "." +
 // |schema[key]|.
@@ skipping 90 matching lines @@
     : original_api_(g_shared_instance_for_test) {
   g_shared_instance_for_test = testing_api;
 }
 
 ExtensionAPI::OverrideSharedInstanceForTest::~OverrideSharedInstanceForTest() {
   g_shared_instance_for_test = original_api_;
 }
 
 void ExtensionAPI::LoadSchema(const std::string& name,
                               const base::StringPiece& schema) {
-  scoped_ptr<base::ListValue> schema_list(LoadSchemaList(name, schema));
+  std::unique_ptr<base::ListValue> schema_list(LoadSchemaList(name, schema));
   std::string schema_namespace;
   extensions::ExtensionsClient* extensions_client =
       extensions::ExtensionsClient::Get();
   DCHECK(extensions_client);
   while (!schema_list->empty()) {
     base::DictionaryValue* schema = NULL;
     {
-      scoped_ptr<base::Value> value;
+      std::unique_ptr<base::Value> value;
       schema_list->Remove(schema_list->GetSize() - 1, &value);
       CHECK(value.release()->GetAsDictionary(&schema));
     }
 
     CHECK(schema->GetString("namespace", &schema_namespace));
     PrefixWithNamespace(schema_namespace, schema);
     schemas_[schema_namespace] = make_linked_ptr(schema);
     if (!extensions_client->IsAPISchemaGenerated(schema_namespace))
       CHECK_EQ(1u, unloaded_schemas_.erase(schema_namespace));
   }
@@ skipping 153 matching lines @@
       break;
 
     api_name_candidate = api_name_candidate.substr(0, last_dot_index);
   }
 
   *child_name = "";
   return std::string();
 }
 
 }  // namespace extensions