Remove ChromeV8Extension & most of ChromeV8Context

chrome/renderer/extensions/messaging_bindings.cc

 // Copyright (c) 2012 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 "chrome/renderer/extensions/messaging_bindings.h"
 
 #include <map>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
 #include "base/values.h"
 #include "chrome/common/extensions/manifest_handlers/externally_connectable.h"
 #include "chrome/common/url_constants.h"
-#include "chrome/renderer/extensions/chrome_v8_context.h"
-#include "chrome/renderer/extensions/chrome_v8_context_set.h"
-#include "chrome/renderer/extensions/chrome_v8_extension.h"
 #include "chrome/renderer/extensions/dispatcher.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/renderer/v8_value_converter.h"
 #include "extensions/common/api/messaging/message.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/renderer/event_bindings.h"
+#include "extensions/renderer/object_backed_native_handler.h"
 #include "extensions/renderer/scoped_persistent.h"
-#include "grit/renderer_resources.h"
+#include "extensions/renderer/script_context.h"
+#include "extensions/renderer/script_context_set.h"
 #include "third_party/WebKit/public/web/WebScopedMicrotaskSuppression.h"
 #include "third_party/WebKit/public/web/WebScopedUserGesture.h"
 #include "third_party/WebKit/public/web/WebScopedWindowFocusAllowedIndicator.h"
 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
 #include "v8/include/v8.h"
 
 // Message passing API example (in a content script):
 // var extension =
 //    new chrome.Extension('00123456789abcdef0123456789abcdef0123456');
 // var port = runtime.connect();
@@ skipping 31 matching lines @@
 }
 
 void ClearPortData(int port_id) {
   g_extension_data.Get().ports.erase(port_id);
 }
 
 const char kPortClosedError[] = "Attempting to use a disconnected port object";
 const char kReceivingEndDoesntExistError[] =
     "Could not establish connection. Receiving end does not exist.";
 
-class ExtensionImpl : public ChromeV8Extension {
+class ExtensionImpl : public ObjectBackedNativeHandler {
  public:
-  ExtensionImpl(Dispatcher* dispatcher, ChromeV8Context* context)
-      : ChromeV8Extension(dispatcher, context) {
+  ExtensionImpl(Dispatcher* dispatcher, ScriptContext* context)
+      : ObjectBackedNativeHandler(context), dispatcher_(dispatcher) {
     RouteFunction("CloseChannel",
         base::Bind(&ExtensionImpl::CloseChannel, base::Unretained(this)));
     RouteFunction("PortAddRef",
         base::Bind(&ExtensionImpl::PortAddRef, base::Unretained(this)));
     RouteFunction("PortRelease",
         base::Bind(&ExtensionImpl::PortRelease, base::Unretained(this)));
     RouteFunction("PostMessage",
         base::Bind(&ExtensionImpl::PostMessage, base::Unretained(this)));
     // TODO(fsamuel, kalman): Move BindToGC out of messaging natives.
     RouteFunction("BindToGC",
         base::Bind(&ExtensionImpl::BindToGC, base::Unretained(this)));
   }
 
   virtual ~ExtensionImpl() {}
 
+ private:
   void ClearPortDataAndNotifyDispatcher(int port_id) {
     ClearPortData(port_id);
-    dispatcher()->ClearPortData(port_id);
+    dispatcher_->ClearPortData(port_id);

[not at google - send to devlin, 2014/04/17 15:11:10]

why does Dispatcher know anything about ports..? weird.

   }
 
   // Sends a message along the given channel.
   void PostMessage(const v8::FunctionCallbackInfo<v8::Value>& args) {
-    content::RenderView* renderview = GetRenderView();
+    content::RenderView* renderview = context()->GetRenderView();
     if (!renderview)
       return;
 
     // Arguments are (int32 port_id, string message).
     CHECK(args.Length() == 2 &&
           args[0]->IsInt32() &&
           args[1]->IsString());
 
     int port_id = args[0]->Int32Value();
     if (!HasPortData(port_id)) {
@@ skipping 107 matching lines @@
   //
   // Binds |callback| to be invoked *sometime after* |object| is garbage
   // collected. We don't call the method re-entrantly so as to avoid executing
   // JS in some bizarro undefined mid-GC state.
   void BindToGC(const v8::FunctionCallbackInfo<v8::Value>& args) {
     CHECK(args.Length() == 2 && args[0]->IsObject() && args[1]->IsFunction());
     GCCallback::Bind(args[0].As<v8::Object>(),
                      args[1].As<v8::Function>(),
                      args.GetIsolate());
   }
+
+  // Dispatcher handle. Not owned.
+  Dispatcher* dispatcher_;
 };
 
 }  // namespace
 
-ChromeV8Extension* MessagingBindings::Get(
-    Dispatcher* dispatcher,
-    ChromeV8Context* context) {
+ObjectBackedNativeHandler* MessagingBindings::Get(Dispatcher* dispatcher,
+                                                  ScriptContext* context) {
   return new ExtensionImpl(dispatcher, context);
 }
 
 // static
 void MessagingBindings::DispatchOnConnect(
-    const ChromeV8ContextSet::ContextSet& contexts,
+    const ScriptContextSet::ContextSet& contexts,
     int target_port_id,
     const std::string& channel_name,
     const base::DictionaryValue& source_tab,
     const std::string& source_extension_id,
     const std::string& target_extension_id,
     const GURL& source_url,
     const std::string& tls_channel_id,
     content::RenderView* restrict_to_render_view) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::HandleScope handle_scope(isolate);
 
   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
 
   bool port_created = false;
   std::string source_url_spec = source_url.spec();
 
-  // TODO(kalman): pass in the full ChromeV8ContextSet; call ForEach.
-  for (ChromeV8ContextSet::ContextSet::const_iterator it = contexts.begin();
-       it != contexts.end(); ++it) {
+  // TODO(kalman): pass in the full ScriptContextSet; call ForEach.
+  for (ScriptContextSet::ContextSet::const_iterator it = contexts.begin();
+       it != contexts.end();
+       ++it) {
     if (restrict_to_render_view &&
         restrict_to_render_view != (*it)->GetRenderView()) {
       continue;
     }
 
     // TODO(kalman): remove when ContextSet::ForEach is available.
     if ((*it)->v8_context().IsEmpty())
       continue;
 
     v8::Handle<v8::Value> tab = v8::Null(isolate);
@@ skipping 62 matching lines @@
   // as a disconnect).
   if (!port_created) {
     content::RenderThread::Get()->Send(
         new ExtensionHostMsg_CloseChannel(
             target_port_id, kReceivingEndDoesntExistError));
   }
 }
 
 // static
 void MessagingBindings::DeliverMessage(
-    const ChromeV8ContextSet::ContextSet& contexts,
+    const ScriptContextSet::ContextSet& contexts,
     int target_port_id,
     const Message& message,
     content::RenderView* restrict_to_render_view) {
   scoped_ptr<blink::WebScopedUserGesture> web_user_gesture;
   scoped_ptr<blink::WebScopedWindowFocusAllowedIndicator> allow_window_focus;
   if (message.user_gesture) {
     web_user_gesture.reset(new blink::WebScopedUserGesture);
     allow_window_focus.reset(new blink::WebScopedWindowFocusAllowedIndicator);
   }
 
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::HandleScope handle_scope(isolate);
 
-  // TODO(kalman): pass in the full ChromeV8ContextSet; call ForEach.
-  for (ChromeV8ContextSet::ContextSet::const_iterator it = contexts.begin();
-       it != contexts.end(); ++it) {
+  // TODO(kalman): pass in the full ScriptContextSet; call ForEach.
+  for (ScriptContextSet::ContextSet::const_iterator it = contexts.begin();
+       it != contexts.end();
+       ++it) {
     if (restrict_to_render_view &&
         restrict_to_render_view != (*it)->GetRenderView()) {
       continue;
     }
 
     // TODO(kalman): remove when ContextSet::ForEach is available.
     if ((*it)->v8_context().IsEmpty())
       continue;
 
     // Check to see whether the context has this port before bothering to create
@@ skipping 16 matching lines @@
                                                 message.data.size()));
     arguments.push_back(port_id_handle);
     (*it)->module_system()->CallModuleMethod("messaging",
                                              "dispatchOnMessage",
                                              &arguments);
   }
 }
 
 // static
 void MessagingBindings::DispatchOnDisconnect(
-    const ChromeV8ContextSet::ContextSet& contexts,
+    const ScriptContextSet::ContextSet& contexts,
     int port_id,
     const std::string& error_message,
     content::RenderView* restrict_to_render_view) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::HandleScope handle_scope(isolate);
 
-  // TODO(kalman): pass in the full ChromeV8ContextSet; call ForEach.
-  for (ChromeV8ContextSet::ContextSet::const_iterator it = contexts.begin();
-       it != contexts.end(); ++it) {
+  // TODO(kalman): pass in the full ScriptContextSet; call ForEach.
+  for (ScriptContextSet::ContextSet::const_iterator it = contexts.begin();
+       it != contexts.end();
+       ++it) {
     if (restrict_to_render_view &&
         restrict_to_render_view != (*it)->GetRenderView()) {
       continue;
     }
 
     // TODO(kalman): remove when ContextSet::ForEach is available.
     if ((*it)->v8_context().IsEmpty())
       continue;
 
     std::vector<v8::Handle<v8::Value> > arguments;
     arguments.push_back(v8::Integer::New(isolate, port_id));
     if (!error_message.empty()) {
       arguments.push_back(
           v8::String::NewFromUtf8(isolate, error_message.c_str()));
     } else {
       arguments.push_back(v8::Null(isolate));
     }
     (*it)->module_system()->CallModuleMethod("messaging",
                                              "dispatchOnDisconnect",
                                              &arguments);
   }
 }
 
 }  // namespace extensions