Refactor to allow same code to test both sync and async functions.

chrome/browser/extensions/extension_function_test_utils.cc

 // Copyright (c) 2011 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 "chrome/browser/extensions/extension_function_test_utils.h"
 
 #include <string>
 
 #include "base/file_path.h"
 #include "base/json/json_reader.h"
@@ skipping 124 matching lines @@
                                         Browser* browser,
                                         RunFunctionFlags flags) {
   scoped_refptr<ExtensionFunction> function_owner(function);
   RunFunction(function, args, browser, flags);
   EXPECT_TRUE(function->GetError().empty()) << "Unexpected error: "
       << function->GetError();
   EXPECT_TRUE(function->GetResultValue()) << "No result value found";
   return function->GetResultValue()->DeepCopy();
 }
 
-void RunFunction(UIThreadExtensionFunction* function,
-                 const std::string& args,
-                 Browser* browser,
-                 RunFunctionFlags flags) {
-  scoped_ptr<base::ListValue> parsed_args(ParseList(args));
-  ASSERT_TRUE(parsed_args.get()) <<
-      "Could not parse extension function arguments: " << args;
-  function->SetArgs(parsed_args.get());
-
-  TestFunctionDispatcherDelegate dispatcher_delegate(browser);
-  ExtensionFunctionDispatcher dispatcher(
-      browser->profile(), &dispatcher_delegate);
-  function->set_dispatcher(dispatcher.AsWeakPtr());
-
-  function->set_profile(browser->profile());
-  function->set_include_incognito(flags & INCLUDE_INCOGNITO);
-  function->Run();
-}
-
 // This helps us be able to wait until an AsyncExtensionFunction calls
 // SendResponse.
-class SendResponseDelegate : public AsyncExtensionFunction::DelegateForTests {
+class SendResponseDelegate
+    : public UIThreadExtensionFunction::DelegateForTests {
  public:
   SendResponseDelegate() : should_post_quit_(false) {}
 
   virtual ~SendResponseDelegate() {}
 
   void set_should_post_quit(bool should_quit) {
     should_post_quit_ = should_quit;
   }
 
   bool HasResponse() {
     return response_.get() != NULL;
   }
 
   bool GetResponse() {
     EXPECT_TRUE(HasResponse());
     return *response_.get();
   }
 
-  virtual void OnSendResponse(AsyncExtensionFunction* function, bool success) {
+  virtual void OnSendResponse(UIThreadExtensionFunction* function,
+                              bool success) {
     ASSERT_FALSE(HasResponse());
     response_.reset(new bool);
     *response_ = success;
     if (should_post_quit_) {
       MessageLoopForUI::current()->Quit();
     }
   }
 
  private:
   scoped_ptr<bool> response_;
   bool should_post_quit_;
 };
 
-bool RunAsyncFunction(AsyncExtensionFunction* function,
-                      const std::string& args,
-                      Browser* browser,
-                      RunFunctionFlags flags) {
+bool RunFunction(UIThreadExtensionFunction* function,
+                 const std::string& args,
+                 Browser* browser,
+                 RunFunctionFlags flags) {
   SendResponseDelegate response_delegate;
   function->set_test_delegate(&response_delegate);
-  RunFunction(function, args, browser, flags);
+  scoped_ptr<base::ListValue> parsed_args(ParseList(args));
+  EXPECT_TRUE(parsed_args.get()) <<
+      "Could not parse extension function arguments: " << args;
+  function->SetArgs(parsed_args.get());
+
+  TestFunctionDispatcherDelegate dispatcher_delegate(browser);
+  ExtensionFunctionDispatcher dispatcher(
+      browser->profile(), &dispatcher_delegate);
+  function->set_dispatcher(dispatcher.AsWeakPtr());
+
+  function->set_profile(browser->profile());
+  function->set_include_incognito(flags & INCLUDE_INCOGNITO);
+  function->Run();
 
   // If the RunImpl of |function| didn't already call SendResponse, run the
   // message loop until they do.
   if (!response_delegate.HasResponse()) {
     response_delegate.set_should_post_quit(true);
     ui_test_utils::RunMessageLoop();
   }
 
   EXPECT_TRUE(response_delegate.HasResponse());
   return response_delegate.GetResponse();
 }
 
 } // namespace extension_function_test_utils