Extensions: Send the tab id to platform apps.

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/api/messaging/message.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/manifest_handlers/externally_connectable.h"
 #include "chrome/common/extensions/message_bundle.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 "chrome/renderer/extensions/event_bindings.h"
+#include "chrome/renderer/extensions/media_galleries_custom_bindings.h"
 #include "chrome/renderer/extensions/scoped_persistent.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/renderer/v8_value_converter.h"
 #include "grit/renderer_resources.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();
 // port.postMessage('Can you hear me now?');
 // port.onmessage.addListener(function(msg, port) {
 //   alert('response=' + msg);
 //   port.postMessage('I got your reponse');
 // });
 
 using content::RenderThread;
 using content::V8ValueConverter;
 
+namespace extensions {
+
 namespace {
 
 struct ExtensionData {
   struct PortData {
     int ref_count;  // how many contexts have a handle to this port
     PortData() : ref_count(0) {}
   };
   std::map<int, PortData> ports;  // port ID -> data
 };
 
@@ skipping 10 matching lines @@
 }
 
 static 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 extensions::ChromeV8Extension {
+class ExtensionImpl : public ChromeV8Extension {
  public:
-  explicit ExtensionImpl(extensions::Dispatcher* dispatcher,
-                         extensions::ChromeV8Context* context)
-      : extensions::ChromeV8Extension(dispatcher, context) {
+  explicit ExtensionImpl(Dispatcher* dispatcher, ChromeV8Context* context)
+      : ChromeV8Extension(dispatcher, context) {
     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",
@@ skipping 15 matching lines @@
 
     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,
-        extensions::Message(
-            *v8::String::Utf8Value(args[1]),
-            blink::WebUserGestureIndicator::isProcessingUserGesture())));
+        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();
@@ skipping 70 matching lines @@
       v8::HandleScope handle_scope(isolate_);
       v8::Handle<v8::Function> callback = callback_.NewHandle(isolate_);
       v8::Handle<v8::Context> context = callback->CreationContext();
       if (context.IsEmpty())
         return;
       v8::Context::Scope context_scope(context);
       blink::WebScopedMicrotaskSuppression suppression;
       callback->Call(context->Global(), 0, NULL);
     }
 
-    extensions::ScopedPersistent<v8::Object> object_;
-    extensions::ScopedPersistent<v8::Function> callback_;
+    ScopedPersistent<v8::Object> object_;
+    ScopedPersistent<v8::Function> callback_;
     v8::Isolate* isolate_;
 
     DISALLOW_COPY_AND_ASSIGN(GCCallback);
   };
 
   // void BindToGC(object, callback)
   //
   // 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());
   }
 };
 
 }  // namespace
 
-namespace extensions {
-
 ChromeV8Extension* MessagingBindings::Get(
     Dispatcher* dispatcher,
     ChromeV8Context* context) {
   return new ExtensionImpl(dispatcher, context);
 }
 
 // static
 void MessagingBindings::DispatchOnConnect(
     const ChromeV8ContextSet::ContextSet& contexts,
     int target_port_id,
@@ skipping 18 matching lines @@
     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);
-    if (!source_tab.empty())
+    if (!source_tab.empty() && (*it)->extension()->is_platform_app())

[not at google - send to devlin, 2014/01/24 21:37:27]

shouldn't this be !is_platform_app() ?

[Lei Zhang, 2014/01/25 01:47:09]

Whoops.

       tab = converter->ToV8Value(&source_tab, (*it)->v8_context());
 
     v8::Handle<v8::Value> tls_channel_id_value = v8::Undefined(isolate);
     if ((*it)->extension()) {
       ExternallyConnectableInfo* externally_connectable =
           ExternallyConnectableInfo::Get((*it)->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()),
-      tab, v8::String::NewFromUtf8(isolate,
-                                   source_extension_id.c_str(),
-                                   v8::String::kNormalString,
-                                   source_extension_id.size()),
+      // sourceTab
+      tab,
+      // sourceExtensionId
+      v8::String::NewFromUtf8(isolate,
+                              source_extension_id.c_str(),
+                              v8::String::kNormalString,
+                              source_extension_id.size()),
+      // targetExtensionId
       v8::String::NewFromUtf8(isolate,
                               target_extension_id.c_str(),
                               v8::String::kNormalString,
                               target_extension_id.size()),
+      // sourceUrl
       v8::String::NewFromUtf8(isolate,
                               source_url_spec.c_str(),
                               v8::String::kNormalString,
                               source_url_spec.size()),
+      // tlsChannelId
       tls_channel_id_value,
     };
 
+    int tab_id = -1;
+    source_tab.GetInteger("id", &tab_id);
+    MediaGalleriesCustomBindings::PushSenderTabId(*it, tab_id);

[not at google - send to devlin, 2014/01/24 21:37:27]

Having this in MediaGalleriesCustomBindings is odd since it's a generic
messaging functionality. Just put the push/pop logic in this class.

I don't understand why you can't have this scoped thing though. The function
call needs to be made synchronously during sendRequest so it will happen within
the CallModuleMethod call below. That could set a global variable somewhere,
with an implicit stack (from the scoped thing saving/restoring the existing tab
ID value) to read out of.

Sorry if I'm missing something here.

[Lei Zhang, 2014/01/25 01:47:09]

Sure, moved here.
Are you assuming the API is synchronous? Media Galleries APIs are async.

[not at google - send to devlin, 2014/01/27 17:51:46]

No, it's an async API, but running the callback itself is synchronous and that's
what matters(?):

chrome.runtime.onMessageExternal.addListener(function() {
  // user action = true, tab ID = 42
  chrome.mediaGalleries.doSomething(function() {
  });
  // user action = false, tab ID = undefined
});

i.e. the chrome.mediaGalleries.doSomething call is executed with that user
action / tab ID state because the event listener has it scoped, so if you read
it from the generic SendRequest place it will be set.

Sorry if I'm missing something.

[Lei Zhang, 2014/01/27 23:19:13]

Ah I see what you mean. I'll try to narrow the scope down and see if we can get
it to a point where we can make it scoped. If you happen to know where that is,
that would be very helpful.

[not at google - send to devlin, 2014/01/27 23:27:40]

So what I'd probably do is have that scoped thing in request_sender.h. Say,
something like:

class RequestSender {
  class ScopedTabID {
    explicit ScopedTabID(RequestSender* rs, int tab_id)
        : rs_(rs), tab_id_(tab_id) {
      old_ = rs->current_tab_id_;
      rs->current_tab_id_ = tab_id;
    }

    ~ScopedTabID() {
      DCHECK_EQ(tab_id_, rs->current_tab_id_);
      rs->current_tab_id_ = old_;
    }

    RequestSender* rs_;
    int tab_id_;
  }

  ...
  friend class ScopedTabID;
  int current_tab_id_;  // start at -1
}

then declare one of those inside the Dispatcher::DispatchEvent call? I think
it's just event dispatching that you need?

sorry rushing through this, hope that's right.

     v8::Handle<v8::Value> retval = (*it)->module_system()->CallModuleMethod(
         "messaging",
         "dispatchOnConnect",
         arraysize(arguments), arguments);
 
     if (retval.IsEmpty()) {
       LOG(ERROR) << "Empty return value from dispatchOnConnect.";
       continue;
     }
 
@@ skipping 85 matching lines @@
       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));
     }
+    MediaGalleriesCustomBindings::PopSenderTabId(*it);
     (*it)->module_system()->CallModuleMethod("messaging",
                                              "dispatchOnDisconnect",
                                              &arguments);
   }
 }
 
 }  // namespace extensions