Make ExtensionFunction::ArgumentList (PKA MultipleArguments) take a scoped_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 <list>
 #include <string>
 
@@ skipping 97 matching lines @@
   //
   // The default implementation is to check the Extension's permissions against
   // what this function requires to run, but some APIs may require finer
   // grained control, such as tabs.executeScript being allowed for active tabs.
   //
   // This will be run after the function has been set up but before Run().
   virtual bool HasPermission();
 
   // The result of a function call.
   //
-  // Use NoArguments(), SingleArgument(), MultipleArguments(), or Error()
+  // 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;
 
   // 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;
 
   // Runs the function and returns the action to take when the caller is ready
   // to respond.
   //
   // Typical return values might be:
   //   * RespondNow(NoArguments())
-  //   * RespondNow(SingleArgument(42))
-  //   * RespondNow(MultipleArguments(my_result.ToValue()))
+  //   * RespondNow(OneArgument(42))
+  //   * RespondNow(ArgumentList(my_result.ToValue()))
   //   * RespondNow(Error("Warp core breach"))
   //   * RespondLater(), then later,
   //     * Respond(NoArguments())
   //     * ... etc.
   //
   //
   // Callers must call Execute() on the return ResponseAction at some point,
   // exactly once.
   //
   // SyncExtensionFunction and AsyncExtensionFunction implement this in terms
@@ skipping 84 matching lines @@
   void set_source_tab_id(int source_tab_id) { source_tab_id_ = source_tab_id; }
   int source_tab_id() const { return source_tab_id_; }
 
  protected:
   friend struct ExtensionFunctionDeleteTraits;
 
   // ResponseValues.
   //
   // Success, no arguments to pass to caller
   ResponseValue NoArguments();
-  // Success, a single argument |result| to pass to caller. TAKES OWNERSHIP.
-  ResponseValue SingleArgument(base::Value* result);
-  // Success, a list of arguments |results| to pass to caller. TAKES OWNERSHIP.
-  ResponseValue MultipleArguments(base::ListValue* results);
+  // 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, 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
+  // result of a ToValue() call on the generated Result struct.
+  ResponseValue ArgumentList(scoped_ptr<base::ListValue> results);
   // Error. chrome.runtime.lastError.message will be set to |error|.
   ResponseValue Error(const std::string& error);
   // Bad message. A ResponseValue equivalent to EXTENSION_FUNCTION_VALIDATE().
   ResponseValue BadMessage();
 
   // ResponseActions.
   //
   // Respond to the extension immediately with |result|.
   ResponseAction RespondNow(ResponseValue result);
   // Don't respond now, but promise to call Respond() later.
@@ skipping 292 matching lines @@
   virtual bool RunSync() = 0;
 
   // ValidationFailure override to match RunSync().
   static bool ValidationFailure(SyncIOThreadExtensionFunction* function);
 
  private:
   virtual ResponseAction Run() OVERRIDE;
 };
 
 #endif  // EXTENSIONS_BROWSER_EXTENSION_FUNCTION_H_