WebstorePrivate extension API cleanup, part 1

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 "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/synchronization/lock.h"
 #include "content/public/browser/notification_source.h"
@@ skipping 42 matching lines @@
 
   ~ArgumentListResponseValue() override {}
 
   bool Apply() override { return true; }
 
  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,
+                                  const std::string& error)
+      : ArgumentListResponseValue(function_name,
+                                  title,
+                                  function,
+                                  result.Pass()) {
+    function->SetError(error);
+  }
+
+  ~ErrorWithArgumentsResponseValue() override {}
+
+  bool Apply() override { return false; }
+};
+
 class ErrorResponseValue : public ExtensionFunction::ResponseValueObject {
  public:
   ErrorResponseValue(ExtensionFunction* function, const std::string& error) {
     // It would be nice to DCHECK(!error.empty()) but too many legacy extension
     // function implementations don't set error but signal failure.
     function->SetError(error);
   }
 
   ~ErrorResponseValue() override {}
 
@@ skipping 251 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,
+    const std::string& error) {
+  return ResponseValue(new ErrorWithArgumentsResponseValue(
+      name(), "ErrorWithArguments", this, args.Pass(), error));
+}
+
 ExtensionFunction::ResponseValue ExtensionFunction::BadMessage() {
   return ResponseValue(new BadMessageResponseValue(this));
 }
 
 ExtensionFunction::ResponseAction ExtensionFunction::RespondNow(
     ResponseValue result) {
   return ResponseAction(new RespondNowAction(
       result.Pass(), base::Bind(&ExtensionFunction::SendResponse, this)));
 }
 
@@ skipping 194 matching lines @@
 
 ExtensionFunction::ResponseAction SyncIOThreadExtensionFunction::Run() {
   return RespondNow(RunSync() ? ArgumentList(results_.Pass()) : Error(error_));
 }
 
 // static
 bool SyncIOThreadExtensionFunction::ValidationFailure(
     SyncIOThreadExtensionFunction* function) {
   return false;
 }