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 101 matching lines @@
 std::string RunFunctionAndReturnError(UIThreadExtensionFunction* function,
                                       const std::string& args,
                                       Browser* browser) {
   return RunFunctionAndReturnError(function, args, browser, NONE);
 }
 std::string RunFunctionAndReturnError(UIThreadExtensionFunction* function,
                                       const std::string& args,
                                       Browser* browser,
                                       RunFunctionFlags flags) {
   scoped_refptr<ExtensionFunction> function_owner(function);
-  RunFunction(function, args, browser, flags);
+  RunAsyncFunction(function, args, browser, flags);
   EXPECT_FALSE(function->GetResultValue()) << "Unexpected function result " <<
       function->GetResult();
   return function->GetError();
 }
 
 base::Value* RunFunctionAndReturnResult(UIThreadExtensionFunction* function,
                                         const std::string& args,
                                         Browser* browser) {
   return RunFunctionAndReturnResult(function, args, browser, NONE);
 }
 base::Value* RunFunctionAndReturnResult(UIThreadExtensionFunction* function,
                                         const std::string& args,
                                         Browser* browser,
                                         RunFunctionFlags flags) {
   scoped_refptr<ExtensionFunction> function_owner(function);
-  RunFunction(function, args, browser, flags);
+  RunAsyncFunction(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,
+bool RunAsyncFunction(UIThreadExtensionFunction* function,
                       const std::string& args,
                       Browser* browser,
                       RunFunctionFlags flags) {
   SendResponseDelegate response_delegate;
   function->set_test_delegate(&response_delegate);
   RunFunction(function, args, browser, flags);
 
   // 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