Add frameId to MessageSender (extension messaging API)

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"
 #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 "content/public/renderer/render_frame.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/common/manifest_handlers/externally_connectable.h"
 #include "extensions/renderer/dispatcher.h"
 #include "extensions/renderer/event_bindings.h"
 #include "extensions/renderer/object_backed_native_handler.h"
 #include "extensions/renderer/scoped_persistent.h"
 #include "extensions/renderer/script_context.h"
 #include "extensions/renderer/script_context_set.h"
@@ skipping 71 matching lines @@
   ~ExtensionImpl() override {}
 
  private:
   void ClearPortDataAndNotifyDispatcher(int port_id) {
     ClearPortData(port_id);
     dispatcher_->ClearPortData(port_id);
   }
 
   // Sends a message along the given channel.
   void PostMessage(const v8::FunctionCallbackInfo<v8::Value>& args) {
-    content::RenderView* renderview = context()->GetRenderView();
-    if (!renderview)
+    content::RenderFrame* renderframe = context()->GetRenderFrame();
+    if (!renderframe)
       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)) {
       args.GetIsolate()->ThrowException(v8::Exception::Error(
           v8::String::NewFromUtf8(args.GetIsolate(), kPortClosedError)));
       return;
     }
 
-    renderview->Send(new ExtensionHostMsg_PostMessage(
-        renderview->GetRoutingID(), port_id,
+    renderframe->Send(new ExtensionHostMsg_PostMessage(
+        renderframe->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]->Int32Value();
     if (!HasPortData(port_id))
       return;
 
-    // Send via the RenderThread because the RenderView might be closing.
+    // Send via the RenderThread because the RenderFrame might be closing.
     bool notify_browser = args[1]->BooleanValue();
     if (notify_browser) {
       content::RenderThread::Get()->Send(
           new ExtensionHostMsg_CloseChannel(port_id, std::string()));
     }
 
     ClearPortDataAndNotifyDispatcher(port_id);
   }
 
   // A new port has been created for a context.  This occurs both when script
@@ skipping 10 matching lines @@
   // 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.
   void PortRelease(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]->Int32Value();
     if (HasPortData(port_id) && --GetPortData(port_id).ref_count == 0) {
-      // Send via the RenderThread because the RenderView might be closing.
+      // Send via the RenderThread because the RenderFrame might be closing.
       content::RenderThread::Get()->Send(
           new ExtensionHostMsg_CloseChannel(port_id, std::string()));
       ClearPortDataAndNotifyDispatcher(port_id);
     }
   }
 
   // Holds a |callback| to run sometime after |object| is GC'ed. |callback| will
   // not be executed re-entrantly to avoid running JS in an unexpected state.
   class GCCallback {
    public:
@@ skipping 51 matching lines @@
                      args.GetIsolate());
   }
 
   // Dispatcher handle. Not owned.
   Dispatcher* dispatcher_;
 };
 
 void DispatchOnConnectToScriptContext(
     int target_port_id,
     const std::string& channel_name,
-    const base::DictionaryValue* source_tab,
+    const ExtensionMsg_TabConnectionInfo* source,
     const ExtensionMsg_ExternalConnectionInfo& info,
     const std::string& tls_channel_id,
     bool* port_created,
     ScriptContext* script_context) {
   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::Handle<v8::Value> tab = v8::Null(isolate);
   v8::Handle<v8::Value> tls_channel_id_value = v8::Undefined(isolate);
 
   if (extension) {
-    if (!source_tab->empty() && !extension->is_platform_app())
-      tab = converter->ToV8Value(source_tab, script_context->v8_context());
+    if (!source->tab.empty() && !extension->is_platform_app())
+      tab = converter->ToV8Value(&source->tab, script_context->v8_context());
 
     ExternallyConnectableInfo* externally_connectable =
         ExternallyConnectableInfo::Get(extension);
     if (externally_connectable &&
         externally_connectable->accepts_tls_channel_id) {
       tls_channel_id_value = v8::String::NewFromUtf8(isolate,
                                                      tls_channel_id.c_str(),
                                                      v8::String::kNormalString,
                                                      tls_channel_id.size());
     }
   }
 
   v8::Handle<v8::Value> arguments[] = {
       // portId
       v8::Integer::New(isolate, target_port_id),
       // channelName
       v8::String::NewFromUtf8(isolate,
                               channel_name.c_str(),
                               v8::String::kNormalString,
                               channel_name.size()),
       // sourceTab
       tab,
+      // source_frame_id
+      v8::Integer::New(isolate, source->frame_id),
       // sourceExtensionId
       v8::String::NewFromUtf8(isolate,
                               info.source_id.c_str(),
                               v8::String::kNormalString,
                               info.source_id.size()),
       // targetExtensionId
       v8::String::NewFromUtf8(isolate,
                               target_extension_id.c_str(),
                               v8::String::kNormalString,
                               target_extension_id.size()),
@@ skipping 70 matching lines @@
 ObjectBackedNativeHandler* MessagingBindings::Get(Dispatcher* dispatcher,
                                                   ScriptContext* context) {
   return new ExtensionImpl(dispatcher, context);
 }
 
 // static
 void MessagingBindings::DispatchOnConnect(
     const ScriptContextSet& context_set,
     int target_port_id,
     const std::string& channel_name,
-    const base::DictionaryValue& source_tab,
+    const ExtensionMsg_TabConnectionInfo& source,
     const ExtensionMsg_ExternalConnectionInfo& info,
     const std::string& tls_channel_id,
-    content::RenderView* restrict_to_render_view) {
+    content::RenderFrame* restrict_to_render_frame) {
+  // TODO(robwu): ScriptContextSet.ForEach should accept RenderFrame*.
+  content::RenderView* restrict_to_render_view =
+      restrict_to_render_frame ? restrict_to_render_frame->GetRenderView()
+                               : NULL;
   bool port_created = false;
-  context_set.ForEach(info.target_id,
-                      restrict_to_render_view,
-                      base::Bind(&DispatchOnConnectToScriptContext,
-                                 target_port_id,
-                                 channel_name,
-                                 &source_tab,
-                                 info,
-                                 tls_channel_id,
-                                 &port_created));
+  context_set.ForEach(
+      info.target_id, restrict_to_render_view,
+      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));
   }
 }
 
 // static
 void MessagingBindings::DeliverMessage(
     const ScriptContextSet& context_set,
     int target_port_id,
     const Message& message,
-    content::RenderView* restrict_to_render_view) {
+    content::RenderFrame* restrict_to_render_frame) {
   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);
   }
 
+  // TODO(robwu): ScriptContextSet.ForEach should accept RenderFrame*.
+  content::RenderView* restrict_to_render_view =
+      restrict_to_render_frame ? restrict_to_render_frame->GetRenderView()
+                               : NULL;
   context_set.ForEach(
       restrict_to_render_view,
       base::Bind(&DeliverMessageToScriptContext, message.data, target_port_id));
 }
 
 // static
 void MessagingBindings::DispatchOnDisconnect(
     const ScriptContextSet& context_set,
     int port_id,
     const std::string& error_message,
-    content::RenderView* restrict_to_render_view) {
+    content::RenderFrame* restrict_to_render_frame) {
+  // TODO(robwu): ScriptContextSet.ForEach should accept RenderFrame*.
+  content::RenderView* restrict_to_render_view =
+      restrict_to_render_frame ? restrict_to_render_frame->GetRenderView()
+                               : NULL;
   context_set.ForEach(
       restrict_to_render_view,
       base::Bind(&DispatchOnDisconnectToScriptContext, port_id, error_message));
 }
 
 }  // namespace extensions