Extensions: Send the tab id to platform apps.

chrome/browser/extensions/api/messaging/message_service.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/browser/extensions/api/messaging/message_service.h"
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/json/json_writer.h"
@@ skipping 101 matching lines @@
 };
 
 namespace {
 
 static base::StaticAtomicSequenceNumber g_next_channel_id;
 static base::StaticAtomicSequenceNumber g_channel_id_overflow_count;
 
 static content::RenderProcessHost* GetExtensionProcess(
     Profile* profile, const std::string& extension_id) {
   SiteInstance* site_instance =
-      ExtensionSystem::Get(profile)->process_manager()->
-          GetSiteInstanceForURL(
-              Extension::GetBaseURLFromExtensionId(extension_id));
-
-  if (!site_instance->HasProcess())
-    return NULL;
-
-  return site_instance->GetProcess();
+      ExtensionSystem::Get(profile)->process_manager()->GetSiteInstanceForURL(
+          Extension::GetBaseURLFromExtensionId(extension_id));
+  return site_instance->HasProcess() ? site_instance->GetProcess() : NULL;
 }
 
 }  // namespace
 
 content::RenderProcessHost*
     MessageService::MessagePort::GetRenderProcessHost() {
   return NULL;
 }
 
 // static
 void MessageService::AllocatePortIdPair(int* port1, int* port2) {
   unsigned channel_id =
       static_cast<unsigned>(g_next_channel_id.GetNext()) % (kint32max/2);
 
   if (channel_id == 0) {
     int overflow_count = g_channel_id_overflow_count.GetNext();
     if (overflow_count > 0)
       UMA_HISTOGRAM_BOOLEAN("Extensions.AllocatePortIdPairOverflow", true);
   }
 
   unsigned port1_id = channel_id * 2;
   unsigned port2_id = channel_id * 2 + 1;
 
   // Sanity checks to make sure our channel<->port converters are correct.
   DCHECK(IS_OPENER_PORT_ID(port1_id));
-  DCHECK(GET_OPPOSITE_PORT_ID(port1_id) == port2_id);
-  DCHECK(GET_OPPOSITE_PORT_ID(port2_id) == port1_id);
-  DCHECK(GET_CHANNEL_ID(port1_id) == GET_CHANNEL_ID(port2_id));
-  DCHECK(GET_CHANNEL_ID(port1_id) == channel_id);
-  DCHECK(GET_CHANNEL_OPENER_ID(channel_id) == port1_id);
-  DCHECK(GET_CHANNEL_RECEIVERS_ID(channel_id) == port2_id);
+  DCHECK_EQ(GET_OPPOSITE_PORT_ID(port1_id), port2_id);
+  DCHECK_EQ(GET_OPPOSITE_PORT_ID(port2_id), port1_id);
+  DCHECK_EQ(GET_CHANNEL_ID(port1_id), GET_CHANNEL_ID(port2_id));
+  DCHECK_EQ(GET_CHANNEL_ID(port1_id), channel_id);
+  DCHECK_EQ(GET_CHANNEL_OPENER_ID(channel_id), port1_id);
+  DCHECK_EQ(GET_CHANNEL_RECEIVERS_ID(channel_id), port2_id);
 
   *port1 = port1_id;
   *port2 = port2_id;
 }
 
 MessageService::MessageService(Profile* profile)
     : lazy_background_task_queue_(
           ExtensionSystem::Get(profile)->lazy_background_task_queue()),
       weak_factory_(this) {
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_TERMINATED,
@@ skipping 125 matching lines @@
   MessagePort* receiver = new ExtensionMessagePort(
       GetExtensionProcess(profile, target_extension_id), MSG_ROUTING_CONTROL,
       target_extension_id);
 
   // Include info about the opener's tab (if it was a tab).
   scoped_ptr<base::DictionaryValue> source_tab;
   GURL source_url_for_tab;
 
   if (source_contents && ExtensionTabUtil::GetTabId(source_contents) >= 0) {
     // Platform apps can be sent messages, but don't have a Tab concept.
-    if (!target_extension->is_platform_app())
-      source_tab.reset(ExtensionTabUtil::CreateTabValue(source_contents));
-    source_url_for_tab = source_url;
+    // Only the tab id is useful to platform apps for internal use. The
+    // unnecessary bits will be stripped out in
+    // MessagingBindings::DispatchOnConnect().
+    source_tab.reset(ExtensionTabUtil::CreateTabValue(source_contents));
   }
+  source_url_for_tab = source_url;

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

I don't think this source_url_for_tab is necessary any more? It only existed so
that we didn't send the URL to the renderer for apps, but now we do.

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

Under |kUrlKey| right? I removed |source_url_for_tab| and read out of
|source_tab| in MessageService::OpenChannelImpl(). If you prefer to do it
elsewhere, let me know.

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

Actually not quite what I meant but what you did is better, and in fact you
could remove the source URL all the way down through ExtensionMessagePort and on
the IPC layer. However perhaps just leave it as a TODO for now and stick with
what you have.

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

Yes, I noticed the rabbit hole is quite deep and I stopped here to keep this CL
small. I added a TODO in MessageService::OpenChannelImpl().

 
   OpenChannelParams* params = new OpenChannelParams(source,
                                                     source_tab.Pass(),
                                                     receiver,
                                                     receiver_port_id,
                                                     source_extension_id,
                                                     target_extension_id,
                                                     source_url_for_tab,
                                                     channel_name,
                                                     include_tls_channel_id);
@@ skipping 222 matching lines @@
   }
 
   // Balance the IncrementLazyKeepaliveCount() in OpenChannelImpl.
   channel->opener->DecrementLazyKeepaliveCount();
   channel->receiver->DecrementLazyKeepaliveCount();
 
   delete channel_iter->second;
   channels_.erase(channel_iter);
 }
 
-void MessageService::PostMessage(
-    int source_port_id, const Message& message) {
+void MessageService::PostMessage(int source_port_id, const Message& message) {
   int channel_id = GET_CHANNEL_ID(source_port_id);
   MessageChannelMap::iterator iter = channels_.find(channel_id);
   if (iter == channels_.end()) {
     // If this channel is pending, queue up the PostMessage to run once
     // the channel opens.
     EnqueuePendingMessage(source_port_id, channel_id, message);
     return;
   }
 
   DispatchMessage(source_port_id, iter->second, message);
@@ skipping 190 matching lines @@
 }
 
 void MessageService::DispatchOnDisconnect(content::RenderProcessHost* source,
                                           int port_id,
                                           const std::string& error_message) {
   ExtensionMessagePort port(source, MSG_ROUTING_CONTROL, "");
   port.DispatchOnDisconnect(GET_OPPOSITE_PORT_ID(port_id), error_message);
 }
 
 }  // namespace extensions