Use FrameTreeNode ID as frameId in extension APIs

extensions/renderer/messaging_bindings.cc

 // Copyright 2014 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/messaging_bindings.h"
 
 #include <map>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 110 matching lines @@
  private:
   // Maps ScriptContexts to the port IDs that have a reference to it.
   std::map<ScriptContext*, std::set<int>> contexts_to_ports_;
 
   DISALLOW_COPY_AND_ASSIGN(PortTracker);
 };
 
 base::LazyInstance<PortTracker> g_port_tracker = LAZY_INSTANCE_INITIALIZER;
 
 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 ObjectBackedNativeHandler {
  public:
   ExtensionImpl(Dispatcher* dispatcher, ScriptContext* context)
       : ObjectBackedNativeHandler(context),
         dispatcher_(dispatcher),
         weak_ptr_factory_(this) {
     RouteFunction(
         "CloseChannel",
         base::Bind(&ExtensionImpl::CloseChannel, base::Unretained(this)));
@@ skipping 23 matching lines @@
       ReleasePort(port_id);
   }
 
   void ClearPortDataAndNotifyDispatcher(int port_id) {
     g_port_tracker.Get().DeletePort(port_id);
     dispatcher_->ClearPortData(port_id);
   }
 
   // Sends a message along the given channel.
   void PostMessage(const v8::FunctionCallbackInfo<v8::Value>& args) {
-    content::RenderFrame* renderframe = context()->GetRenderFrame();
-    if (!renderframe)
+    content::RenderFrame* render_frame = context()->GetRenderFrame();
+    if (!render_frame)
       return;
 
     // Arguments are (int32 port_id, string message).
     CHECK(args.Length() == 2 && args[0]->IsInt32() && args[1]->IsString());
 
     int port_id = args[0].As<v8::Int32>()->Value();
     if (!g_port_tracker.Get().HasPort(port_id)) {
       v8::Local<v8::String> error_message =
           ToV8StringUnsafe(args.GetIsolate(), kPortClosedError);
       args.GetIsolate()->ThrowException(v8::Exception::Error(error_message));
       return;
     }
 
-    renderframe->Send(new ExtensionHostMsg_PostMessage(
-        renderframe->GetRoutingID(), port_id,
+    render_frame->Send(new ExtensionHostMsg_PostMessage(
+        render_frame->GetRoutingID(), port_id,
         Message(*v8::String::Utf8Value(args[1]),
                 blink::WebUserGestureIndicator::isProcessingUserGesture())));
   }
 
   // Forcefully disconnects a port.
   void CloseChannel(const v8::FunctionCallbackInfo<v8::Value>& args) {
     // Arguments are (int32 port_id, boolean notify_browser).
     CHECK_EQ(2, args.Length());
     CHECK(args[0]->IsInt32());
     CHECK(args[1]->IsBoolean());
 
     int port_id = args[0].As<v8::Int32>()->Value();
     if (!g_port_tracker.Get().HasPort(port_id))
       return;
 
     // Send via the RenderThread because the RenderFrame might be closing.
     bool notify_browser = args[1].As<v8::Boolean>()->Value();
-    if (notify_browser) {
-      content::RenderThread::Get()->Send(
-          new ExtensionHostMsg_CloseChannel(port_id, std::string()));
+    content::RenderFrame* render_frame = context()->GetRenderFrame();
+    if (notify_browser && render_frame) {
+      render_frame->Send(new ExtensionHostMsg_CloseMessagePort(
+          render_frame->GetRoutingID(), port_id, true));
     }
 
     ClearPortDataAndNotifyDispatcher(port_id);
   }
 
   // A new port has been created for a context.  This occurs both when script
   // opens a connection, and when a connection is opened to this script.
   void PortAddRef(const v8::FunctionCallbackInfo<v8::Value>& args) {
     // Arguments are (int32 port_id).
     CHECK_EQ(1, args.Length());
     CHECK(args[0]->IsInt32());
 
     int port_id = args[0].As<v8::Int32>()->Value();
     g_port_tracker.Get().AddReference(context(), port_id);
   }
 
   // The frame a port lived in has been destroyed.  When there are no more
   // frames with a reference to a given port, we will disconnect it and notify
   // the other end of the channel.
+  // TODO(robwu): Port lifetime management has moved to the browser, this is no
+  // longer needed. See .destroy_() inmessaging.js for more details.
   void PortRelease(const v8::FunctionCallbackInfo<v8::Value>& args) {
     // Arguments are (int32 port_id).
     CHECK(args.Length() == 1 && args[0]->IsInt32());
     ReleasePort(args[0].As<v8::Int32>()->Value());
   }
 
   // Releases the reference to |port_id| for this context, and clears all port
   // data if there are no more references.
   void ReleasePort(int port_id) {
+    content::RenderFrame* render_frame = context()->GetRenderFrame();
     if (g_port_tracker.Get().RemoveReference(context(), port_id) &&
-        !g_port_tracker.Get().HasPort(port_id)) {
-      // Send via the RenderThread because the RenderFrame might be closing.
-      content::RenderThread::Get()->Send(
-          new ExtensionHostMsg_CloseChannel(port_id, std::string()));
-      ClearPortDataAndNotifyDispatcher(port_id);
+        !g_port_tracker.Get().HasPort(port_id) && render_frame) {
+      render_frame->Send(new ExtensionHostMsg_CloseMessagePort(
+          render_frame->GetRoutingID(), port_id, false));
     }
   }
 
   // void BindToGC(object, callback, port_id)
   //
   // 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, nor do we then call into the
   // script context if it's been invalidated.
   //
@@ skipping 20 matching lines @@
 };
 
 void DispatchOnConnectToScriptContext(
     int target_port_id,
     const std::string& channel_name,
     const ExtensionMsg_TabConnectionInfo* source,
     const ExtensionMsg_ExternalConnectionInfo& info,
     const std::string& tls_channel_id,
     bool* port_created,
     ScriptContext* script_context) {
-  // Only dispatch the events if this is the requested target frame (0 = main
-  // frame; positive = child frame).
-  content::RenderFrame* renderframe = script_context->GetRenderFrame();
-  if (info.target_frame_id == 0 && renderframe->GetWebFrame()->parent() != NULL)
-    return;
-  if (info.target_frame_id > 0 &&
-      renderframe->GetRoutingID() != info.target_frame_id)
-    return;
-
-  // Bandaid fix for crbug.com/520303.
-  // TODO(rdevlin.cronin): Fix this properly by routing messages to the correct
-  // RenderFrame from the browser (same with |target_frame_id| in fact).
-  if (info.target_tab_id != -1 &&
-      info.target_tab_id != ExtensionFrameHelper::Get(renderframe)->tab_id()) {
-    return;
-  }
-
   v8::Isolate* isolate = script_context->isolate();
   v8::HandleScope handle_scope(isolate);
 
   scoped_ptr<V8ValueConverter> converter(V8ValueConverter::create());
 
   const std::string& source_url_spec = info.source_url.spec();
   std::string target_extension_id = script_context->GetExtensionID();
   const Extension* extension = script_context->extension();
 
   v8::Local<v8::Value> tab = v8::Null(isolate);
@@ skipping 149 matching lines @@
     const ExtensionMsg_TabConnectionInfo& source,
     const ExtensionMsg_ExternalConnectionInfo& info,
     const std::string& tls_channel_id,
     content::RenderFrame* restrict_to_render_frame) {
   bool port_created = false;
   context_set.ForEach(
       info.target_id, restrict_to_render_frame,
       base::Bind(&DispatchOnConnectToScriptContext, target_port_id,
                  channel_name, &source, info, tls_channel_id, &port_created));
 
-  // If we didn't create a port, notify the other end of the channel (treat it
-  // as a disconnect).
-  if (!port_created) {
-    content::RenderThread::Get()->Send(new ExtensionHostMsg_CloseChannel(
-        target_port_id, kReceivingEndDoesntExistError));
+  int routing_id = restrict_to_render_frame
+                       ? restrict_to_render_frame->GetRoutingID()
+                       : MSG_ROUTING_NONE;
+  if (port_created) {
+    content::RenderThread::Get()->Send(
+        new ExtensionHostMsg_OpenMessagePort(routing_id, target_port_id));
+  } else {
+    content::RenderThread::Get()->Send(new ExtensionHostMsg_CloseMessagePort(
+        routing_id, target_port_id, false));
   }
 }
 
 // static
 void MessagingBindings::DeliverMessage(
     const ScriptContextSet& context_set,
     int target_port_id,
     const Message& message,
     content::RenderFrame* restrict_to_render_frame) {
   context_set.ForEach(
       restrict_to_render_frame,
       base::Bind(&DeliverMessageToScriptContext, message, target_port_id));
 }
 
 // static
 void MessagingBindings::DispatchOnDisconnect(
     const ScriptContextSet& context_set,
     int port_id,
     const std::string& error_message,
     content::RenderFrame* restrict_to_render_frame) {
   context_set.ForEach(
       restrict_to_render_frame,
       base::Bind(&DispatchOnDisconnectToScriptContext, port_id, error_message));
 }
 
 }  // namespace extensions