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"
@@ skipping 222 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) {
   bool port_created = false;
   context_set.ForEach(info.target_id,
                       restrict_to_render_view,
                       base::Bind(&DispatchOnConnectToScriptContext,
                                  target_port_id,
                                  channel_name,
-                                 &source_tab,
+                                 &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));
   }
@@ skipping 22 matching lines @@
     const ScriptContextSet& context_set,
     int port_id,
     const std::string& error_message,
     content::RenderView* restrict_to_render_view) {
   context_set.ForEach(
       restrict_to_render_view,
       base::Bind(&DispatchOnDisconnectToScriptContext, port_id, error_message));
 }
 
 }  // namespace extensions