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

extensions/browser/extension_function.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/browser/extension_function.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/singleton.h"
 #include "base/synchronization/lock.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "extensions/browser/extension_function_dispatcher.h"
 #include "extensions/browser/extension_message_filter.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/extension_api.h"
 #include "extensions/common/extension_messages.h"
 
 using content::BrowserThread;
 using content::RenderViewHost;
 using content::WebContents;
 using extensions::ErrorUtils;
 using extensions::ExtensionAPI;
 using extensions::Feature;
 
 namespace {
 
 class ArgumentListResponseValue
     : public ExtensionFunction::ResponseValueObject {
  public:
   ArgumentListResponseValue(const std::string& function_name,
                             const char* title,
                             ExtensionFunction* function,
-                            scoped_ptr<base::ListValue> result)
+                            std::unique_ptr<base::ListValue> result)
       : function_name_(function_name), title_(title) {
     if (function->GetResultList()) {
       DCHECK_EQ(function->GetResultList(), result.get())
           << "The result set on this function (" << function_name_ << ") "
           << "either by calling SetResult() or directly modifying |result_| is "
           << "different to the one passed to " << title_ << "(). "
           << "The best way to fix this problem is to exclusively use " << title_
           << "(). SetResult() and |result_| are deprecated.";
     } else {
       function->SetResultList(std::move(result));
@@ skipping 10 matching lines @@
  private:
   std::string function_name_;
   const char* title_;
 };
 
 class ErrorWithArgumentsResponseValue : public ArgumentListResponseValue {
  public:
   ErrorWithArgumentsResponseValue(const std::string& function_name,
                                   const char* title,
                                   ExtensionFunction* function,
-                                  scoped_ptr<base::ListValue> result,
+                                  std::unique_ptr<base::ListValue> result,
                                   const std::string& error)
       : ArgumentListResponseValue(function_name,
                                   title,
                                   function,
                                   std::move(result)) {
     function->SetError(error);
   }
 
   ~ErrorWithArgumentsResponseValue() override {}
 
@@ skipping 174 matching lines @@
 void ExtensionFunction::SetArgs(const base::ListValue* args) {
   DCHECK(!args_.get());  // Should only be called once.
   args_.reset(args->DeepCopy());
 }
 
 void ExtensionFunction::SetResult(base::Value* result) {
   results_.reset(new base::ListValue());
   results_->Append(result);
 }
 
-void ExtensionFunction::SetResult(scoped_ptr<base::Value> result) {
+void ExtensionFunction::SetResult(std::unique_ptr<base::Value> result) {
   results_.reset(new base::ListValue());
   results_->Append(std::move(result));
 }
 
-void ExtensionFunction::SetResultList(scoped_ptr<base::ListValue> results) {
+void ExtensionFunction::SetResultList(
+    std::unique_ptr<base::ListValue> results) {
   results_ = std::move(results);
 }
 
 const base::ListValue* ExtensionFunction::GetResultList() const {
   return results_.get();
 }
 
 std::string ExtensionFunction::GetError() const {
   return error_;
 }
 
 void ExtensionFunction::SetError(const std::string& error) {
   error_ = error;
 }
 
 bool ExtensionFunction::user_gesture() const {
   return user_gesture_ || UserGestureForTests::GetInstance()->HaveGesture();
 }
 
 ExtensionFunction::ResponseValue ExtensionFunction::NoArguments() {
   return ResponseValue(new ArgumentListResponseValue(
-      name(), "NoArguments", this, make_scoped_ptr(new base::ListValue())));
+      name(), "NoArguments", this, base::WrapUnique(new base::ListValue())));
 }
 
 ExtensionFunction::ResponseValue ExtensionFunction::OneArgument(
     base::Value* arg) {
-  scoped_ptr<base::ListValue> args(new base::ListValue());
+  std::unique_ptr<base::ListValue> args(new base::ListValue());
   args->Append(arg);
   return ResponseValue(new ArgumentListResponseValue(name(), "OneArgument",
                                                      this, std::move(args)));
 }
 
 ExtensionFunction::ResponseValue ExtensionFunction::OneArgument(
-    scoped_ptr<base::Value> arg) {
+    std::unique_ptr<base::Value> arg) {
   return OneArgument(arg.release());
 }
 
 ExtensionFunction::ResponseValue ExtensionFunction::TwoArguments(
     base::Value* arg1,
     base::Value* arg2) {
-  scoped_ptr<base::ListValue> args(new base::ListValue());
+  std::unique_ptr<base::ListValue> args(new base::ListValue());
   args->Append(arg1);
   args->Append(arg2);
   return ResponseValue(new ArgumentListResponseValue(name(), "TwoArguments",
                                                      this, std::move(args)));
 }
 
 ExtensionFunction::ResponseValue ExtensionFunction::ArgumentList(
-    scoped_ptr<base::ListValue> args) {
+    std::unique_ptr<base::ListValue> args) {
   return ResponseValue(new ArgumentListResponseValue(name(), "ArgumentList",
                                                      this, std::move(args)));
 }
 
 ExtensionFunction::ResponseValue ExtensionFunction::Error(
     const std::string& error) {
   return ResponseValue(new ErrorResponseValue(this, error));
 }
 
 ExtensionFunction::ResponseValue ExtensionFunction::Error(
@@ skipping 14 matching lines @@
 ExtensionFunction::ResponseValue ExtensionFunction::Error(
     const std::string& format,
     const std::string& s1,
     const std::string& s2,
     const std::string& s3) {
   return ResponseValue(new ErrorResponseValue(
       this, ErrorUtils::FormatErrorMessage(format, s1, s2, s3)));
 }
 
 ExtensionFunction::ResponseValue ExtensionFunction::ErrorWithArguments(
-    scoped_ptr<base::ListValue> args,
+    std::unique_ptr<base::ListValue> args,
     const std::string& error) {
   return ResponseValue(new ErrorWithArgumentsResponseValue(
       name(), "ErrorWithArguments", this, std::move(args), error));
 }
 
 ExtensionFunction::ResponseValue ExtensionFunction::BadMessage() {
   return ResponseValue(new BadMessageResponseValue(this));
 }
 
 ExtensionFunction::ResponseAction ExtensionFunction::RespondNow(
@@ skipping 192 matching lines @@
 ExtensionFunction::ResponseAction SyncIOThreadExtensionFunction::Run() {
   return RespondNow(RunSync() ? ArgumentList(std::move(results_))
                               : Error(error_));
 }
 
 // static
 bool SyncIOThreadExtensionFunction::ValidationFailure(
     SyncIOThreadExtensionFunction* function) {
   return false;
 }