Drive extension functions from ExtensionFunction::Run. The

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 "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_frame_host.h"
@@ skipping 16 matching lines @@
 class MultipleArgumentsResponseValue
     : public ExtensionFunction::ResponseValueObject {
  public:
   MultipleArgumentsResponseValue(ExtensionFunction* function,
                                  base::ListValue* result) {
     if (function->GetResultList()) {
       DCHECK_EQ(function->GetResultList(), result);
     } else {
       function->SetResultList(make_scoped_ptr(result));
     }
-    DCHECK_EQ("", function->GetError());
+    // It would be nice to DCHECK(error.empty()) but some legacy extension
+    // function implementations... I'm looking at chrome.input.ime... do this
+    // for some reason.
   }
 
   virtual ~MultipleArgumentsResponseValue() {}
 
   virtual bool Apply() OVERRIDE { return true; }
 };
 
 class ErrorResponseValue : public ExtensionFunction::ResponseValueObject {
  public:
   ErrorResponseValue(ExtensionFunction* function, const std::string& error) {
-    DCHECK_NE("", 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);
   }
 
   virtual ~ErrorResponseValue() {}
 
   virtual bool Apply() OVERRIDE { return false; }
 };
 
 class BadMessageResponseValue : public ExtensionFunction::ResponseValueObject {
  public:
@@ skipping 166 matching lines @@
 ExtensionFunction::ResponseAction ExtensionFunction::RespondNow(
     ResponseValue result) {
   return scoped_ptr<ResponseActionObject>(new RespondNowAction(
       result.Pass(), base::Bind(&ExtensionFunction::SendResponse, this)));
 }
 
 ExtensionFunction::ResponseAction ExtensionFunction::RespondLater() {
   return scoped_ptr<ResponseActionObject>(new RespondLaterAction());
 }
 
-void ExtensionFunction::Run() {
-  if (!RunImpl())
-    SendResponse(false);
-}
-
-bool ExtensionFunction::RunImpl() {
-  RunImplTypesafe()->Execute();
-  return true;
-}
-
-ExtensionFunction::ResponseAction ExtensionFunction::RunImplTypesafe() {
-  NOTREACHED()
-      << "ExtensionFunctions must override either RunImpl or RunImplTypesafe";
-  return RespondNow(NoArguments());
-}
-
-void ExtensionFunction::SendResponseTypesafe(ResponseValue response) {
-  SendResponse(response->Apply());
+void ExtensionFunction::Respond(ResponseValue result) {
+  SendResponse(result->Apply());
 }
 
 bool ExtensionFunction::ShouldSkipQuotaLimiting() const {
   return false;
 }
 
 bool ExtensionFunction::HasOptionalArgument(size_t index) {
   base::Value* value;
   return args_->Get(index, &value) && !value->IsType(base::Value::TYPE_NULL);
 }
 
 void ExtensionFunction::SendResponseImpl(bool success) {
   DCHECK(!response_callback_.is_null());
 
   ResponseType type = success ? SUCCEEDED : FAILED;
   if (bad_message_) {
     type = BAD_MESSAGE;
     LOG(ERROR) << "Bad extension message " << name_;
   }
 
   // If results were never set, we send an empty argument list.
   if (!results_)
     results_.reset(new base::ListValue());
 
   response_callback_.Run(type, *results_, GetError());
 }
 
+void ExtensionFunction::OnRespondingLater(ResponseValue value) {
+  SendResponse(value->Apply());
+}
+
 UIThreadExtensionFunction::UIThreadExtensionFunction()
     : render_view_host_(NULL),
       render_frame_host_(NULL),
       context_(NULL),
       delegate_(NULL) {
 }
 
 UIThreadExtensionFunction::~UIThreadExtensionFunction() {
   if (dispatcher() && render_view_host())
     dispatcher()->OnExtensionFunctionCompleted(GetExtension());
@@ skipping 72 matching lines @@
 void IOThreadExtensionFunction::SendResponse(bool success) {
   SendResponseImpl(success);
 }
 
 AsyncExtensionFunction::AsyncExtensionFunction() {
 }
 
 AsyncExtensionFunction::~AsyncExtensionFunction() {
 }
 
+ExtensionFunction::ResponseAction AsyncExtensionFunction::Run() {
+  return RunAsync() ? RespondLater() : RespondNow(Error(error_));
+}
+
 SyncExtensionFunction::SyncExtensionFunction() {
 }
 
 SyncExtensionFunction::~SyncExtensionFunction() {
 }
 
-bool SyncExtensionFunction::RunImpl() {
-  SendResponse(RunSync());
-  return true;
+ExtensionFunction::ResponseAction SyncExtensionFunction::Run() {
+  return RespondNow(RunSync() ? MultipleArguments(results_.get())
+                              : Error(error_));
 }
 
 SyncIOThreadExtensionFunction::SyncIOThreadExtensionFunction() {
 }
 
 SyncIOThreadExtensionFunction::~SyncIOThreadExtensionFunction() {
 }
 
-bool SyncIOThreadExtensionFunction::RunImpl() {
-  SendResponse(RunSync());
-  return true;
+ExtensionFunction::ResponseAction SyncIOThreadExtensionFunction::Run() {
+  return RespondNow(RunSync() ? MultipleArguments(results_.get())
+                              : Error(error_));
 }