[Extensions Bindings] Introduce BindingAccessChecker

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 "extensions/renderer/api_binding.h"
 #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_hooks.h"
 #include "extensions/renderer/api_binding_hooks_test_delegate.h"
 #include "extensions/renderer/api_binding_test.h"
 #include "extensions/renderer/api_binding_test_util.h"
 #include "extensions/renderer/api_event_handler.h"
 #include "extensions/renderer/api_invocation_errors.h"
 #include "extensions/renderer/api_request_handler.h"
 #include "extensions/renderer/api_type_reference_map.h"
+#include "extensions/renderer/binding_access_checker.h"
 #include "gin/arguments.h"
 #include "gin/converter.h"
 #include "gin/public/context_holder.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/web/WebScopedUserGesture.h"
 #include "v8/include/v8.h"
 
 namespace extensions {
 
 using namespace api_errors;
@@ skipping 66 matching lines @@
     APIBindingTest::SetUp();
     request_handler_ = base::MakeUnique<APIRequestHandler>(
         base::Bind(&APIBindingUnittest::OnFunctionCall, base::Unretained(this)),
         base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
         APILastError(APILastError::GetParent(),
                      APILastError::AddConsoleError()));
   }
 
   void TearDown() override {
     DisposeAllContexts();
+    access_checker_.reset();
     request_handler_.reset();
     event_handler_.reset();
     binding_.reset();
     APIBindingTest::TearDown();
   }
 
   void OnWillDisposeContext(v8::Local<v8::Context> context) override {
     event_handler_->InvalidateContext(context);
     request_handler_->InvalidateContext(context);
   }
@@ skipping 27 matching lines @@
       std::unique_ptr<APIBindingHooksDelegate> hooks_delegate) {
     binding_hooks_delegate_ = std::move(hooks_delegate);
     ASSERT_TRUE(binding_hooks_delegate_);
   }
 
   void SetCreateCustomType(const APIBinding::CreateCustomType& callback) {
     create_custom_type_ = callback;
   }
 
   void SetAvailabilityCallback(
-      const APIBinding::AvailabilityCallback& callback) {
+      const BindingAccessChecker::AvailabilityCallback& callback) {
     availability_callback_ = callback;
   }
 
   void InitializeBinding() {
     if (!binding_hooks_) {
       binding_hooks_ = base::MakeUnique<APIBindingHooks>(
           kBindingName, binding::RunJSFunctionSync());
     }
     if (binding_hooks_delegate_)
       binding_hooks_->SetDelegate(std::move(binding_hooks_delegate_));
     if (!availability_callback_)
       availability_callback_ = base::Bind(&AllowAllFeatures);
     event_handler_ = base::MakeUnique<APIEventHandler>(
         base::Bind(&RunFunctionOnGlobalAndIgnoreResult),
         base::Bind(&RunFunctionOnGlobalAndReturnHandle),
         base::Bind(&OnEventListenersChanged));
+    access_checker_ =
+        base::MakeUnique<BindingAccessChecker>(availability_callback_);
     binding_ = base::MakeUnique<APIBinding>(
         kBindingName, binding_functions_.get(), binding_types_.get(),
         binding_events_.get(), binding_properties_.get(), create_custom_type_,
-        availability_callback_, std::move(binding_hooks_), &type_refs_,
-        request_handler_.get(), event_handler_.get());
+        std::move(binding_hooks_), &type_refs_, request_handler_.get(),
+        event_handler_.get(), access_checker_.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(MainContext(), object, script_source,
                expected_json_arguments_single_quotes, expect_callback);
   }
@@ skipping 38 matching lines @@
                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<APIRequestHandler::Request> last_request_;
   std::unique_ptr<APIBinding> binding_;
   std::unique_ptr<APIEventHandler> event_handler_;
   std::unique_ptr<APIRequestHandler> request_handler_;
+  std::unique_ptr<BindingAccessChecker> access_checker_;
   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_;
   std::unique_ptr<APIBindingHooksDelegate> binding_hooks_delegate_;
   APIBinding::CreateCustomType create_custom_type_;
-  APIBinding::AvailabilityCallback availability_callback_;
+  BindingAccessChecker::AvailabilityCallback availability_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(APIBindingUnittest);
 };
 
 void APIBindingUnittest::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,
@@ skipping 1016 matching lines @@
 
   // The extra property should be present on the binding object.
   EXPECT_EQ("42", GetStringPropertyFromObject(binding_object, context,
                                               "hookedProperty"));
   // Sanity check: other values should still be there.
   EXPECT_EQ("function",
             GetStringPropertyFromObject(binding_object, context, "oneString"));
 }
 
 }  // namespace extensions