[Extensions Bindings] Apply per-context restrictions to events

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 129 matching lines @@
       : 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 {
+    DisposeAllContexts();
     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);
+  }
+
   void SetFunctions(const char* functions) {
     binding_functions_ = ListValueFromString(functions);
     ASSERT_TRUE(binding_functions_);
   }
 
   void SetEvents(const char* events) {
     binding_events_ = ListValueFromString(events);
     ASSERT_TRUE(binding_events_);
   }
 
@@ skipping 323 matching lines @@
   ExpectFailure(binding_object, "obj.takesRefObj({prop1: 'foo', prop2: 'a'})",
                 kError);
   ExpectPass(binding_object, "obj.takesRefEnum('alpha')", "['alpha']", false);
   ExpectPass(binding_object, "obj.takesRefEnum('beta')", "['beta']", false);
   ExpectPass(binding_object, "obj.takesRefEnum(obj.refEnum.BETA)", "['beta']",
              false);
   ExpectFailure(binding_object, "obj.takesRefEnum('gamma')", kError);
 }
 
 TEST_F(APIBindingUnittest, RestrictedAPIs) {
-  const char kRestrictedFunctions[] =
+  const char kFunctions[] =
       "[{"
       "  'name': 'allowedOne',"
       "  'parameters': []"
       "}, {"
       "  'name': 'allowedTwo',"
       "  'parameters': []"
       "}, {"
       "  'name': 'restrictedOne',"
       "  'parameters': []"
       "}, {"
       "  'name': 'restrictedTwo',"
       "  'parameters': []"
       "}]";
-  SetFunctions(kRestrictedFunctions);
+  SetFunctions(kFunctions);
+  const char kEvents[] =
+      "[{'name': 'allowedEvent'}, {'name': 'restrictedEvent'}]";
+  SetEvents(kEvents);
   InitializeBinding();
 
   v8::HandleScope handle_scope(isolate());
   v8::Local<v8::Context> context = MainContext();
 
   auto is_available = [](const std::string& name) {
-    std::set<std::string> functions = {"test.allowedOne", "test.allowedTwo",
-                                       "test.restrictedOne",
-                                       "test.restrictedTwo"};
-    EXPECT_TRUE(functions.count(name));
-    return name == "test.allowedOne" || name == "test.allowedTwo";
+    std::set<std::string> allowed = {"test.allowedOne", "test.allowedTwo",
+                                     "test.allowedEvent"};
+    std::set<std::string> restricted = {
+        "test.restrictedOne", "test.restrictedTwo", "test.restrictedEvent"};
+    EXPECT_TRUE(allowed.count(name) || restricted.count(name)) << name;
+    return allowed.count(name) != 0;
   };
 
   v8::Local<v8::Object> binding_object =
       binding()->CreateInstance(context, isolate(), base::Bind(is_available));
 
   auto is_defined = [&binding_object, context](const std::string& name) {
     v8::Local<v8::Value> val =
         GetPropertyFromObject(binding_object, context, name);
     EXPECT_FALSE(val.IsEmpty());
     return !val->IsUndefined() && !val->IsNull();
   };
 
   EXPECT_TRUE(is_defined("allowedOne"));
   EXPECT_TRUE(is_defined("allowedTwo"));
+  EXPECT_TRUE(is_defined("allowedEvent"));
   EXPECT_FALSE(is_defined("restrictedOne"));
   EXPECT_FALSE(is_defined("restrictedTwo"));
+  EXPECT_FALSE(is_defined("restrictedEvent"));
 }
 
 // Tests that events specified in the API are created as properties of the API
 // object.
 TEST_F(APIBindingUnittest, TestEventCreation) {
   SetEvents("[{'name': 'onFoo'}, {'name': 'onBar'}]");
   SetFunctions(kFunctions);
   InitializeBinding();
 
   v8::HandleScope handle_scope(isolate());
@@ skipping 605 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