Drive extension functions from ExtensionFunction::Run. The

extensions/browser/extension_function_dispatcher.cc

 // Copyright 2014 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_dispatcher.h"
 
 #include "base/bind.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 256 matching lines @@
                                               &params.arguments,
                                               base::TimeTicks::Now());
   if (violation_error.empty()) {
     scoped_ptr<base::ListValue> args(params.arguments.DeepCopy());
     NotifyApiFunctionCalled(extension->id(),
                             params.name,
                             args.Pass(),
                             static_cast<content::BrowserContext*>(profile_id));
     UMA_HISTOGRAM_SPARSE_SLOWLY("Extensions.FunctionCalls",
                                 function->histogram_value());
-    function->Run();
+    function->Run()->Execute();

[not at google - send to devlin, 2014/04/30 15:25:46]

I also find this a bit weird. At least Run() can have WARN_UNUSED_RESULT, and
there are a very small number of call sites, but still... weird.

It's also weird that "Run" and "Execute" are synonyms yet sort-of mean different
things here. Maybe "Execute" should be renamed "Respond" or "Reply" or "Send"?

I decided this was better than making those RespondNow() functions immediately
do their action, since they could declare those "ResponseAction" variables
locally and expect them not to do anything. This could be made to work by
changing Run() to return void again, and get rid of ResponseAction. An option I
didn't immediately consider since I like the "return" aspect, the point was
enforcing at the type level that only a single thing can happen.

Another option would be to define a
RunAndExecute()/RunAndRespond()/RunAndReply()/RunAndSend() function on
ExtensionFunction(), define Run() as protected, then the only option here would
be to call that.

[Ken Rockot(use gerrit already), 2014/04/30 23:38:08]

Of all the suggested verbs, I like "Send" the best, but I'd still like to think
about this some more now that you bring it up...

[not at google - send to devlin, 2014/04/30 23:54:39]

No rush :)

   } else {
     function->OnQuotaExceeded(violation_error);
   }
 }
 
 ExtensionFunctionDispatcher::ExtensionFunctionDispatcher(
     content::BrowserContext* browser_context,
     Delegate* delegate)
     : browser_context_(browser_context),
       delegate_(delegate) {
@@ skipping 87 matching lines @@
                                               function.get(),
                                               &params.arguments,
                                               base::TimeTicks::Now());
   if (violation_error.empty()) {
     scoped_ptr<base::ListValue> args(params.arguments.DeepCopy());
 
     NotifyApiFunctionCalled(
         extension->id(), params.name, args.Pass(), browser_context_);
     UMA_HISTOGRAM_SPARSE_SLOWLY("Extensions.FunctionCalls",
                                 function->histogram_value());
-    function->Run();
+    function->Run()->Execute();
   } else {
     function->OnQuotaExceeded(violation_error);
   }
 
   // Note: do not access |this| after this point. We may have been deleted
   // if function->Run() ended up closing the tab that owns us.
 
   // Check if extension was uninstalled by management.uninstall.
   if (!registry->enabled_extensions().GetByID(params.extension_id))
     return;
@@ skipping 112 matching lines @@
 
 // static
 void ExtensionFunctionDispatcher::SendAccessDenied(
     const ExtensionFunction::ResponseCallback& callback) {
   base::ListValue empty_list;
   callback.Run(ExtensionFunction::FAILED, empty_list,
                "Access to extension API denied.");
 }
 
 }  // namespace extensions