[Extensions Bindings] Move request dispatch to APIRequestHandler

extensions/renderer/api_binding_unittest.cc

 // Copyright 2016 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 "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "extensions/renderer/api_binding.h"
@@ skipping 108 matching lines @@
 }
 
 void OnEventListenersChanged(const std::string& event_name,
                              binding::EventListenersChanged change,
                              v8::Local<v8::Context> context) {}
 
 }  // namespace
 
 class APIBindingUnittest : public APIBindingTest {
  public:
-  void OnFunctionCall(std::unique_ptr<APIBinding::Request> request,
+  void OnFunctionCall(std::unique_ptr<APIRequestHandler::Request> request,
                       v8::Local<v8::Context> context) {
     last_request_ = std::move(request);
   }
 
  protected:
   APIBindingUnittest()
       : type_refs_(APITypeReferenceMap::InitializeTypeCallback()) {}
   void SetUp() override {
     APIBindingTest::SetUp();
     request_handler_ = base::MakeUnique<APIRequestHandler>(
+        base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
         base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
         APILastError(APILastError::GetParent()));
   }
 
   void TearDown() override {
     request_handler_.reset();
     event_handler_.reset();
     binding_.reset();
     APIBindingTest::TearDown();
   }
@@ skipping 27 matching lines @@
     if (!binding_hooks_) {
       binding_hooks_ =
           base::MakeUnique<APIBindingHooks>(binding::RunJSFunctionSync());
     }
     event_handler_ = base::MakeUnique<APIEventHandler>(
         base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
         base::Bind(&OnEventListenersChanged));
     binding_ = base::MakeUnique<APIBinding>(
         "test", binding_functions_.get(), binding_types_.get(),
         binding_events_.get(), binding_properties_.get(),
-        base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
         std::move(binding_hooks_), &type_refs_, request_handler_.get(),
         event_handler_.get());
     EXPECT_EQ(!binding_types_.get(), type_refs_.empty());
   }
 
   void ExpectPass(v8::Local<v8::Object> object,
                   const std::string& script_source,
                   const std::string& expected_json_arguments_single_quotes,
                   bool expect_callback) {
     ExpectPass(ContextLocal(), object, script_source,
@@ skipping 11 matching lines @@
   }
 
   void ExpectFailure(v8::Local<v8::Object> object,
                      const std::string& script_source,
                      const std::string& expected_error) {
     RunTest(ContextLocal(), object, script_source, false, std::string(), false,
             expected_error);
   }
 
   bool HandlerWasInvoked() const { return last_request_ != nullptr; }
-  const APIBinding::Request* last_request() const {
+  const APIRequestHandler::Request* last_request() const {
     return last_request_.get();
   }
   void reset_last_request() { last_request_.reset(); }
   APIBinding* binding() { return binding_.get(); }
   APIEventHandler* event_handler() { return event_handler_.get(); }
   APIRequestHandler* request_handler() { return request_handler_.get(); }
   const APITypeReferenceMap& type_refs() const { return type_refs_; }
 
  private:
   void RunTest(v8::Local<v8::Context> context,
                v8::Local<v8::Object> object,
                const std::string& script_source,
                bool should_pass,
                const std::string& expected_json_arguments,
                bool expect_callback,
                const std::string& expected_error);
 
-  std::unique_ptr<APIBinding::Request> last_request_;
+  std::unique_ptr<APIRequestHandler::Request> last_request_;
   std::unique_ptr<APIBinding> binding_;
   std::unique_ptr<APIEventHandler> event_handler_;
   std::unique_ptr<APIRequestHandler> request_handler_;
   APITypeReferenceMap type_refs_;
 
   std::unique_ptr<base::ListValue> binding_functions_;
   std::unique_ptr<base::ListValue> binding_events_;
   std::unique_ptr<base::ListValue> binding_types_;
   std::unique_ptr<base::DictionaryValue> binding_properties_;
   std::unique_ptr<APIBindingHooks> binding_hooks_;
@@ skipping 797 matching lines @@
 
   blink::WebScopedUserGesture user_gesture(nullptr);
   RunFunction(function, context, arraysize(argv), argv);
   ASSERT_TRUE(last_request());
   EXPECT_TRUE(last_request()->has_user_gesture);
 
   reset_last_request();
 }
 
 }  // namespace extensions