[Extensions] Clean up the handling of ExtensionHostMsg_Request

extensions/browser/api_test_utils.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/api_test_utils.h"
 
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "components/crx_file/id_util.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/browser/extension_function.h"
 #include "extensions/browser/extension_function_dispatcher.h"
 #include "extensions/common/extension_builder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using extensions::ExtensionFunctionDispatcher;
 
 namespace {
 
-class TestFunctionDispatcherDelegate
-    : public ExtensionFunctionDispatcher::Delegate {
- public:
-  TestFunctionDispatcherDelegate() {}
-  ~TestFunctionDispatcherDelegate() override {}
-
-  // NULL implementation.
- private:
-  DISALLOW_COPY_AND_ASSIGN(TestFunctionDispatcherDelegate);
-};
-
 scoped_ptr<base::Value> ParseJSON(const std::string& data) {
   return base::JSONReader::Read(data);
 }
 
 scoped_ptr<base::ListValue> ParseList(const std::string& data) {
   scoped_ptr<base::Value> result = ParseJSON(data);
   scoped_ptr<base::ListValue> list_result;
   if (result->GetAsList(nullptr))
     list_result.reset(static_cast<base::ListValue*>(result.release()));
   return list_result;
@@ skipping 135 matching lines @@
     const std::string& args,
     content::BrowserContext* context) {
   return RunFunctionAndReturnSingleResult(function, args, context, NONE);
 }
 
 base::Value* RunFunctionAndReturnSingleResult(
     UIThreadExtensionFunction* function,
     const std::string& args,
     content::BrowserContext* context,
     RunFunctionFlags flags) {
-  TestFunctionDispatcherDelegate delegate;
   scoped_ptr<ExtensionFunctionDispatcher> dispatcher(
-      new ExtensionFunctionDispatcher(context, &delegate));
+      new ExtensionFunctionDispatcher(context));
 
   return RunFunctionWithDelegateAndReturnSingleResult(
       function, args, context, dispatcher.Pass(), flags);
 }
 
 std::string RunFunctionAndReturnError(UIThreadExtensionFunction* function,
                                       const std::string& args,
                                       content::BrowserContext* context) {
   return RunFunctionAndReturnError(function, args, context, NONE);
 }
 
 std::string RunFunctionAndReturnError(UIThreadExtensionFunction* function,
                                       const std::string& args,
                                       content::BrowserContext* context,
                                       RunFunctionFlags flags) {
-  TestFunctionDispatcherDelegate delegate;
   scoped_ptr<ExtensionFunctionDispatcher> dispatcher(
-      new ExtensionFunctionDispatcher(context, &delegate));
+      new ExtensionFunctionDispatcher(context));
   scoped_refptr<ExtensionFunction> function_owner(function);
   // Without a callback the function will not generate a result.
   function->set_has_callback(true);
   RunFunction(function, args, context, dispatcher.Pass(), flags);
   EXPECT_FALSE(function->GetResultList()) << "Did not expect a result";
   return function->GetError();
 }
 
 bool RunFunction(UIThreadExtensionFunction* function,
                  const std::string& args,
                  content::BrowserContext* context) {
-  TestFunctionDispatcherDelegate delegate;
   scoped_ptr<ExtensionFunctionDispatcher> dispatcher(
-      new ExtensionFunctionDispatcher(context, &delegate));
+      new ExtensionFunctionDispatcher(context));
   return RunFunction(function, args, context, dispatcher.Pass(), NONE);
 }
 
 bool RunFunction(UIThreadExtensionFunction* function,
                  const std::string& args,
                  content::BrowserContext* context,
                  scoped_ptr<extensions::ExtensionFunctionDispatcher> dispatcher,
                  RunFunctionFlags flags) {
   scoped_ptr<base::ListValue> parsed_args = ParseList(args);
   EXPECT_TRUE(parsed_args.get())
@@ skipping 24 matching lines @@
     response_delegate.set_should_post_quit(true);
     content::RunMessageLoop();
   }
 
   EXPECT_TRUE(response_delegate.HasResponse());
   return response_delegate.GetResponse();
 }
 
 }  // namespace api_test_utils
 }  // namespace extensions