[Extensions Bindings] Add Events support

extensions/renderer/api_bindings_system_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_bindings_system.h"
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
@@ skipping 35 matching lines @@
     "    }]"
     "  }, {"
     "    'name': 'functionWithRefAndCallback',"
     "    'parameters': [{"
     "      'name': 'ref',"
     "      '$ref': 'objRef'"
     "    }, {"
     "      'name': 'callback',"
     "      'type': 'function'"
     "    }]"
+    "  }],"
+    "  'events': [{"
+    "    'name': 'alphaEvent'"
     "  }]"
     "}";
 
 // Another fake API for testing.
 const char kBetaAPIName[] = "beta";
 const char kBetaAPISpec[] =
     "{"
     "  'functions': [{"
     "    'name': 'simpleFunc',"
     "    'parameters': [{'name': 'int', 'type': 'integer'}]"
@@ skipping 20 matching lines @@
     ASSERT_FALSE(last_request_);
     last_request_ = std::move(request);
   }
 
  protected:
   APIBindingsSystemTestBase() {}
   void SetUp() override;
 
   void TearDown() override {
     bindings_system_.reset();
+
+    v8::Global<v8::Context> weak_context(instance_->isolate(), context_);
+    weak_context.SetWeak();
+
     holder_.reset();
-    gin::V8Test::TearDown();
+
+    // NOTE: We explicitly do NOT call gin::V8Test::TearDown() here because we
+    // do intermittent validation by doing a garbage collection after context
+    // destruction and ensuring the context is fully released (which wouldn't
+    // happen in cycles).
+    // TODO(devlin): It might be time to move off V8Test if we're doing this.
+    {
+      v8::HandleScope handle_scope(instance_->isolate());
+      v8::Local<v8::Context>::New(instance_->isolate(), context_)->Exit();
+      context_.Reset();
+    }
+
+    // Garbage collect everything so that we find any issues where we might be
+    // double-freeing.
+    // '5' is a magic number stolen from Blink; arbitrarily large enough to
+    // hopefully clean up all the various paths.
+    for (int i = 0; i < 5; i++) {
+      instance_->isolate()->RequestGarbageCollectionForTesting(
+          v8::Isolate::kFullGarbageCollection);
+    }
+
+    ASSERT_TRUE(weak_context.IsEmpty());
+
+    instance_->isolate()->Exit();
+    instance_.reset();
   }
 
   // Checks that |last_request_| exists and was provided with the
   // |expected_name| and |expected_arguments|.
   void ValidateLastRequest(const std::string& expected_name,
                            const std::string& expected_arguments);
 
   const APIBindingsSystem::Request* last_request() const {
     return last_request_.get();
   }
@@ skipping 155 matching lines @@
                                        base::ListValue());
 
     std::unique_ptr<base::Value> result = GetBaseValuePropertyFromObject(
         context->Global(), context, "callbackArguments");
     ASSERT_TRUE(result);
     EXPECT_EQ("[]", ValueToString(*result));
     reset_last_request();
   }
 
   {
+    // Test an event registration -> event occurrence.
+    const char kTestCall[] =
+        "obj.alphaEvent.addListener(function() {\n"
+        "  this.eventArguments = Array.from(arguments);\n"
+        "});\n";
+    CallFunctionOnObject(context, alpha_api, kTestCall);
+
+    const char kResponseArgsJson[] = "['response',1,{'key':42}]";
+    std::unique_ptr<base::ListValue> expected_args =
+        ListValueFromString(kResponseArgsJson);
+    bindings_system()->FireEventInContext("alpha.alphaEvent", context,
+                                          *expected_args);
+
+    std::unique_ptr<base::Value> result = GetBaseValuePropertyFromObject(
+        context->Global(), context, "eventArguments");
+    ASSERT_TRUE(result);
+    EXPECT_EQ(ReplaceSingleQuotes(kResponseArgsJson), ValueToString(*result));
+  }
+
+  {
     // Test a call -> response on the second API.
     const char kTestCall[] = "obj.simpleFunc(2)";
     CallFunctionOnObject(context, beta_api, kTestCall);
     ValidateLastRequest("beta.simpleFunc", "[2]");
     EXPECT_TRUE(last_request()->request_id.empty());
     reset_last_request();
   }
 }
 
 // An implementation using real API schemas.
@@ skipping 126 matching lines @@
     reset_last_request();  // Just to not pollute future results.
   }
 
   {
     // The queryState() param has a minimum of 15.
     const char kTestCall[] = "chrome.idle.queryState(10, function() {});";
     ExecuteScriptAndExpectError(context, kTestCall, kError);
     EXPECT_FALSE(last_request());
     reset_last_request();  // Just to not pollute future results.
   }
+
+  {
+    const char kTestCall[] =
+        "chrome.idle.onStateChanged.addListener(state => {\n"
+        "  this.idleState = state;\n"
+        "});\n";
+    ExecuteScript(context, kTestCall);
+    v8::Local<v8::Value> v8_result =
+        GetPropertyFromObject(context->Global(), context, "idleState");
+    EXPECT_TRUE(v8_result->IsUndefined());
+    bindings_system()->FireEventInContext("idle.onStateChanged", context,
+                                          *ListValueFromString("['active']"));
+
+    std::unique_ptr<base::Value> result =
+        GetBaseValuePropertyFromObject(context->Global(), context, "idleState");
+    ASSERT_TRUE(result);
+    EXPECT_EQ("\"active\"", ValueToString(*result));
+  }
 }
 
 }  // namespace extensions