Convert //extensions/browser from scoped_ptr to std::unique_ptr

extensions/browser/api_test_utils.cc

 // Copyright 2014 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/browser/api_test_utils.h"
 
+#include <memory>
 #include <utility>
 
 #include "base/json/json_reader.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "components/crx_file/id_util.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/browser/extension_function.h"
 #include "extensions/browser/extension_function_dispatcher.h"
 #include "extensions/common/extension_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using extensions::ExtensionFunctionDispatcher;
 
 namespace {
 
-scoped_ptr<base::Value> ParseJSON(const std::string& data) {
+std::unique_ptr<base::Value> ParseJSON(const std::string& data) {
   return base::JSONReader::Read(data);
 }
 
-scoped_ptr<base::ListValue> ParseList(const std::string& data) {
+std::unique_ptr<base::ListValue> ParseList(const std::string& data) {
   return base::ListValue::From(ParseJSON(data));
 }
 
 // This helps us be able to wait until an UIThreadExtensionFunction calls
 // SendResponse.
 class SendResponseDelegate
     : public UIThreadExtensionFunction::DelegateForTests {
  public:
   SendResponseDelegate() : should_post_quit_(false) {}
 
@@ skipping 16 matching lines @@
     ASSERT_FALSE(bad_message);
     ASSERT_FALSE(HasResponse());
     response_.reset(new bool);
     *response_ = success;
     if (should_post_quit_) {
       base::MessageLoopForUI::current()->QuitWhenIdle();
     }
   }
 
  private:
-  scoped_ptr<bool> response_;
+  std::unique_ptr<bool> response_;
   bool should_post_quit_;
 };
 
 }  // namespace
 
 namespace extensions {
 
 namespace api_test_utils {
 
-scoped_ptr<base::DictionaryValue> ParseDictionary(const std::string& data) {
+std::unique_ptr<base::DictionaryValue> ParseDictionary(
+    const std::string& data) {
   return base::DictionaryValue::From(ParseJSON(data));
 }
 
 bool GetBoolean(const base::DictionaryValue* val, const std::string& key) {
   bool result = false;
   if (!val->GetBoolean(key, &result))
     ADD_FAILURE() << key << " does not exist or is not a boolean.";
   return result;
 }
 
@@ skipping 29 matching lines @@
 }
 
 scoped_refptr<Extension> CreateExtension(
     base::DictionaryValue* test_extension_value) {
   return CreateExtension(Manifest::INTERNAL, test_extension_value,
                          std::string());
 }
 
 scoped_refptr<Extension> CreateEmptyExtensionWithLocation(
     Manifest::Location location) {
-  scoped_ptr<base::DictionaryValue> test_extension_value =
+  std::unique_ptr<base::DictionaryValue> test_extension_value =
       ParseDictionary("{\"name\": \"Test\", \"version\": \"1.0\"}");
   return CreateExtension(location, test_extension_value.get(), std::string());
 }
 
 base::Value* RunFunctionWithDelegateAndReturnSingleResult(
     UIThreadExtensionFunction* function,
     const std::string& args,
     content::BrowserContext* context,
-    scoped_ptr<extensions::ExtensionFunctionDispatcher> dispatcher) {
+    std::unique_ptr<extensions::ExtensionFunctionDispatcher> dispatcher) {
   return RunFunctionWithDelegateAndReturnSingleResult(
       function, args, context, std::move(dispatcher), NONE);
 }
 
 base::Value* RunFunctionWithDelegateAndReturnSingleResult(
     UIThreadExtensionFunction* function,
     const std::string& args,
     content::BrowserContext* context,
-    scoped_ptr<extensions::ExtensionFunctionDispatcher> dispatcher,
+    std::unique_ptr<extensions::ExtensionFunctionDispatcher> dispatcher,
     RunFunctionFlags flags) {
   scoped_refptr<ExtensionFunction> function_owner(function);
   // Without a callback the function will not generate a result.
   function->set_has_callback(true);
   RunFunction(function, args, context, std::move(dispatcher), flags);
   EXPECT_TRUE(function->GetError().empty())
       << "Unexpected error: " << function->GetError();
   const base::Value* single_result = NULL;
   if (function->GetResultList() != NULL &&
       function->GetResultList()->Get(0, &single_result)) {
     return single_result->DeepCopy();
   }
   return NULL;
 }
 
 base::Value* RunFunctionAndReturnSingleResult(
     UIThreadExtensionFunction* function,
     const std::string& args,
     content::BrowserContext* context) {
   return RunFunctionAndReturnSingleResult(function, args, context, NONE);
 }
 
 base::Value* RunFunctionAndReturnSingleResult(
     UIThreadExtensionFunction* function,
     const std::string& args,
     content::BrowserContext* context,
     RunFunctionFlags flags) {
-  scoped_ptr<ExtensionFunctionDispatcher> dispatcher(
+  std::unique_ptr<ExtensionFunctionDispatcher> dispatcher(
       new ExtensionFunctionDispatcher(context));
 
   return RunFunctionWithDelegateAndReturnSingleResult(
       function, args, context, std::move(dispatcher), flags);
 }
 
 std::string RunFunctionAndReturnError(UIThreadExtensionFunction* function,
                                       const std::string& args,
                                       content::BrowserContext* context) {
   return RunFunctionAndReturnError(function, args, context, NONE);
 }
 
 std::string RunFunctionAndReturnError(UIThreadExtensionFunction* function,
                                       const std::string& args,
                                       content::BrowserContext* context,
                                       RunFunctionFlags flags) {
-  scoped_ptr<ExtensionFunctionDispatcher> dispatcher(
+  std::unique_ptr<ExtensionFunctionDispatcher> dispatcher(
       new ExtensionFunctionDispatcher(context));
   scoped_refptr<ExtensionFunction> function_owner(function);
   // Without a callback the function will not generate a result.
   function->set_has_callback(true);
   RunFunction(function, args, context, std::move(dispatcher), flags);
   EXPECT_FALSE(function->GetResultList()) << "Did not expect a result";
   return function->GetError();
 }
 
 bool RunFunction(UIThreadExtensionFunction* function,
                  const std::string& args,
                  content::BrowserContext* context) {
-  scoped_ptr<ExtensionFunctionDispatcher> dispatcher(
+  std::unique_ptr<ExtensionFunctionDispatcher> dispatcher(
       new ExtensionFunctionDispatcher(context));
   return RunFunction(function, args, context, std::move(dispatcher), NONE);
 }
 
-bool RunFunction(UIThreadExtensionFunction* function,
-                 const std::string& args,
-                 content::BrowserContext* context,
-                 scoped_ptr<extensions::ExtensionFunctionDispatcher> dispatcher,
-                 RunFunctionFlags flags) {
-  scoped_ptr<base::ListValue> parsed_args = ParseList(args);
+bool RunFunction(
+    UIThreadExtensionFunction* function,
+    const std::string& args,
+    content::BrowserContext* context,
+    std::unique_ptr<extensions::ExtensionFunctionDispatcher> dispatcher,
+    RunFunctionFlags flags) {
+  std::unique_ptr<base::ListValue> parsed_args = ParseList(args);
   EXPECT_TRUE(parsed_args.get())
       << "Could not parse extension function arguments: " << args;
   return RunFunction(function, std::move(parsed_args), context,
                      std::move(dispatcher), flags);
 }
 
-bool RunFunction(UIThreadExtensionFunction* function,
-                 scoped_ptr<base::ListValue> args,
-                 content::BrowserContext* context,
-                 scoped_ptr<extensions::ExtensionFunctionDispatcher> dispatcher,
-                 RunFunctionFlags flags) {
+bool RunFunction(
+    UIThreadExtensionFunction* function,
+    std::unique_ptr<base::ListValue> args,
+    content::BrowserContext* context,
+    std::unique_ptr<extensions::ExtensionFunctionDispatcher> dispatcher,
+    RunFunctionFlags flags) {
   SendResponseDelegate response_delegate;
   function->set_test_delegate(&response_delegate);
   function->SetArgs(args.get());
 
   CHECK(dispatcher);
   function->set_dispatcher(dispatcher->AsWeakPtr());
 
   function->set_browser_context(context);
   function->set_include_incognito(flags & INCLUDE_INCOGNITO);
   function->Run()->Execute();
 
   // If the RunAsync of |function| didn't already call SendResponse, run the
   // message loop until they do.
   if (!response_delegate.HasResponse()) {
     response_delegate.set_should_post_quit(true);
     content::RunMessageLoop();
   }
 
   EXPECT_TRUE(response_delegate.HasResponse());
   return response_delegate.GetResponse();
 }
 
 }  // namespace api_test_utils
 }  // namespace extensions