[Extensions Bindings] Add a bridge to use current custom bindings

extensions/renderer/api_binding_bridge.h

Index: extensions/renderer/api_binding_bridge.h
diff --git a/extensions/renderer/api_binding_bridge.h b/extensions/renderer/api_binding_bridge.h
new file mode 100644
index 0000000000000000000000000000000000000000..a3d517740cd15f9211eb715afed7e9847287ef4f
--- /dev/null
+++ b/extensions/renderer/api_binding_bridge.h
@@ -0,0 +1,60 @@
+// 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.
+
+#ifndef EXTENSIONS_RENDERER_API_BINDING_BRIDGE_H_
+#define EXTENSIONS_RENDERER_API_BINDING_BRIDGE_H_
+
+#include <string>
+
+#include "base/macros.h"
+#include "extensions/renderer/api_binding_types.h"
+#include "gin/wrappable.h"
+#include "v8/include/v8.h"
+
+namespace extensions {
+
+// An object that serves as a bridge between the current JS-centric bindings and
+// the new native bindings system. This basically needs to conform to the public
+// methods of the Binding prototype in binding.js.
+class APIBindingBridge final : public gin::Wrappable<APIBindingBridge> {
+ public:
+  APIBindingBridge(v8::Global<v8::Value> api_object,
+                   v8::Global<v8::Value> js_hooks_interface,
+                   const std::string& extension_id,
+                   const std::string& context_type,
+                   const binding::RunJSFunction& run_js);
+  ~APIBindingBridge() override;
+
+  static gin::WrapperInfo kWrapperInfo;
+
+  // gin::Wrappable:
+  gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
+      v8::Isolate* isolate) final;
+
+ private:
+  // Runs the given function and registers custom hooks.
+  void RegisterCustomHook(v8::Isolate* isolate,
+                          v8::Local<v8::Function> function);
+
+  // The API object itself.
+  v8::Global<v8::Value> api_object_;

[jbroman, 2016/12/16 19:00:49]

I'm not confident about the lifetime of this and the below global. In
particular, this cycle looks uncollectable to me:

APIBindingBridge -> api object -> ??? -> APIBindingBridge

Thus keeping the whole context alive if there's any references from the API
object (or anything it references, including its creation context). Either we
need to make certain these cycles cannot happen (which is hard to do when author
script can mess with things), or that these references are definitely cleared,
or that these references occur in the V8 heap where the GC can see them.

One way to do the last would be to store them as a property of the wrapper
(which is how gin::Timer works, for instance). You can store a property with a
private symbol as a key (so script could never get access to that symbol), and
then retrieve it from the wrapper if you need it.

If this is already safe for some reason that's not obvious to me, it definitely
merits documentation.

[Devlin, 2016/12/16 20:31:17]

Thanks for catching this!  I definitely still haven't learned all the ins and
outs of v8 lifetime, so I appreciate the skeptical eye. :)  I've adopted the
private property approach.

+
+  // The JS interface to register hooks.
+  v8::Global<v8::Value> js_hooks_interface_;
+
+  // The id of the extension that owns the context this belongs to.
+  std::string extension_id_;
+
+  // The type of context this belongs to.
+  std::string context_type_;
+
+  // A function to run JS safely.
+  binding::RunJSFunction run_js_;
+
+  DISALLOW_COPY_AND_ASSIGN(APIBindingBridge);
+};
+
+}  // namespace extensions
+
+#endif  // EXTENSIONS_RENDERER_API_BINDING_BRIDGE_H_