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

extensions/browser/extension_function.h

 // 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.
 
 #ifndef EXTENSIONS_BROWSER_EXTENSION_FUNCTION_H_
 #define EXTENSIONS_BROWSER_EXTENSION_FUNCTION_H_
 
 #include <stddef.h>
 
 #include <list>
+#include <memory>
 #include <string>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/process/process.h"
 #include "base/sequenced_task_runner_helpers.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/console_message_level.h"
 #include "extensions/browser/extension_function_histogram_value.h"
 #include "extensions/browser/info_map.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/features/feature.h"
 #include "ipc/ipc_message.h"
@@ skipping 99 matching lines @@
   //
   // Use NoArguments(), OneArgument(), ArgumentList(), or Error()
   // rather than this class directly.
   class ResponseValueObject {
    public:
     virtual ~ResponseValueObject() {}
 
     // Returns true for success, false for failure.
     virtual bool Apply() = 0;
   };
-  typedef scoped_ptr<ResponseValueObject> ResponseValue;
+  typedef std::unique_ptr<ResponseValueObject> ResponseValue;
 
   // The action to use when returning from RunAsync.
   //
   // Use RespondNow() or RespondLater() rather than this class directly.
   class ResponseActionObject {
    public:
     virtual ~ResponseActionObject() {}
 
     virtual void Execute() = 0;
   };
-  typedef scoped_ptr<ResponseActionObject> ResponseAction;
+  typedef std::unique_ptr<ResponseActionObject> ResponseAction;
 
   // Helper class for tests to force all ExtensionFunction::user_gesture()
   // calls to return true as long as at least one instance of this class
   // exists.
   class ScopedUserGestureForTests {
    public:
     ScopedUserGestureForTests();
     ~ScopedUserGestureForTests();
   };
 
@@ skipping 37 matching lines @@
       extensions::QuotaLimitHeuristics* heuristics) const {}
 
   // Called when the quota limit has been exceeded. The default implementation
   // returns an error.
   virtual void OnQuotaExceeded(const std::string& violation_error);
 
   // Specifies the raw arguments to the function, as a JSON value.
   virtual void SetArgs(const base::ListValue* args);
 
   // Sets a single Value as the results of the function.
-  void SetResult(scoped_ptr<base::Value> result);
+  void SetResult(std::unique_ptr<base::Value> result);
   // As above, but deprecated. TODO(estade): remove.
   void SetResult(base::Value* result);
 
   // Sets multiple Values as the results of the function.
-  void SetResultList(scoped_ptr<base::ListValue> results);
+  void SetResultList(std::unique_ptr<base::ListValue> results);
 
   // Retrieves the results of the function as a ListValue.
   const base::ListValue* GetResultList() const;
 
   // Retrieves any error string from the function.
   virtual std::string GetError() const;
 
   // Sets the function's error string.
   virtual void SetError(const std::string& error);
 
@@ skipping 71 matching lines @@
 
   // ResponseValues.
   //
   // Success, no arguments to pass to caller.
   ResponseValue NoArguments();
   // Success, a single argument |arg| to pass to caller. TAKES OWNERSHIP - a
   // raw pointer for convenience, since callers usually construct the argument
   // to this by hand.
   ResponseValue OneArgument(base::Value* arg);
   // Success, a single argument |arg| to pass to caller.
-  ResponseValue OneArgument(scoped_ptr<base::Value> arg);
+  ResponseValue OneArgument(std::unique_ptr<base::Value> arg);
   // Success, two arguments |arg1| and |arg2| to pass to caller. TAKES
   // OWNERSHIP - raw pointers for convenience, since callers usually construct
   // the argument to this by hand. Note that use of this function may imply you
   // should be using the generated Result struct and ArgumentList.
   ResponseValue TwoArguments(base::Value* arg1, base::Value* arg2);
   // Success, a list of arguments |results| to pass to caller. TAKES OWNERSHIP
-  // - a scoped_ptr<> for convenience, since callers usually get this from the
+  // - a std::unique_ptr<> for convenience, since callers usually get this from
+  // the
   // result of a Create(...) call on the generated Results struct, for example,
   // alarms::Get::Results::Create(alarm).
-  ResponseValue ArgumentList(scoped_ptr<base::ListValue> results);
+  ResponseValue ArgumentList(std::unique_ptr<base::ListValue> results);
   // Error. chrome.runtime.lastError.message will be set to |error|.
   ResponseValue Error(const std::string& error);
   // Error with formatting. Args are processed using
   // ErrorUtils::FormatErrorMessage, that is, each occurence of * is replaced
   // by the corresponding |s*|:
   // Error("Error in *: *", "foo", "bar") <--> Error("Error in foo: bar").
   ResponseValue Error(const std::string& format, const std::string& s1);
   ResponseValue Error(const std::string& format,
                       const std::string& s1,
                       const std::string& s2);
   ResponseValue Error(const std::string& format,
                       const std::string& s1,
                       const std::string& s2,
                       const std::string& s3);
   // Error with a list of arguments |args| to pass to caller. TAKES OWNERSHIP.
   // Using this ResponseValue indicates something is wrong with the API.
   // It shouldn't be possible to have both an error *and* some arguments.
   // Some legacy APIs do rely on it though, like webstorePrivate.
-  ResponseValue ErrorWithArguments(scoped_ptr<base::ListValue> args,
+  ResponseValue ErrorWithArguments(std::unique_ptr<base::ListValue> args,
                                    const std::string& error);
   // Bad message. A ResponseValue equivalent to EXTENSION_FUNCTION_VALIDATE(),
   // so this will actually kill the renderer and not respond at all.
   ResponseValue BadMessage();
 
   // ResponseActions.
   //
   // These are exclusively used as return values from Run(). Call Respond(...)
   // to respond at any other time - but as described below, only after Run()
   // has already executed, and only if it returned RespondLater().
@@ skipping 57 matching lines @@
   // True if this callback should include information from incognito contexts
   // even if our profile_ is non-incognito. Note that in the case of a "split"
   // mode extension, this will always be false, and we will limit access to
   // data from within the same profile_ (either incognito or not).
   bool include_incognito_;
 
   // True if the call was made in response of user gesture.
   bool user_gesture_;
 
   // The arguments to the API. Only non-null if argument were specified.
-  scoped_ptr<base::ListValue> args_;
+  std::unique_ptr<base::ListValue> args_;
 
   // The results of the API. This should be populated by the derived class
   // before SendResponse() is called.
-  scoped_ptr<base::ListValue> results_;
+  std::unique_ptr<base::ListValue> results_;
 
   // Any detailed error from the API. This should be populated by the derived
   // class before Run() returns.
   std::string error_;
 
   // Any class that gets a malformed message should set this to true before
   // returning.  Usually we want to kill the message sending process.
   bool bad_message_;
 
   // The sample value to record with the histogram API when the function
@@ skipping 104 matching lines @@
   class RenderFrameHostTracker;
 
   void Destruct() const override;
 
   // The dispatcher that will service this extension function call.
   base::WeakPtr<extensions::ExtensionFunctionDispatcher> dispatcher_;
 
   // The RenderFrameHost we will send responses to.
   content::RenderFrameHost* render_frame_host_;
 
-  scoped_ptr<RenderFrameHostTracker> tracker_;
+  std::unique_ptr<RenderFrameHostTracker> tracker_;
 
   DelegateForTests* delegate_;
 
   // The blobs transferred to the renderer process.
   std::vector<std::string> transferred_blob_uuids_;
 
   DISALLOW_COPY_AND_ASSIGN(UIThreadExtensionFunction);
 };
 
 // Extension functions that run on the IO thread. This type of function avoids
@@ skipping 129 matching lines @@
  private:
   // If you're hitting a compile error here due to "final" - great! You're
   // doing the right thing, you just need to extend IOThreadExtensionFunction
   // instead of SyncIOExtensionFunction.
   ResponseAction Run() final;
 
   DISALLOW_COPY_AND_ASSIGN(SyncIOThreadExtensionFunction);
 };
 
 #endif  // EXTENSIONS_BROWSER_EXTENSION_FUNCTION_H_