Fix a couple of bugs relating to sending Tab info with chrome.runtime.connect and

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 14 matching lines @@
 #include "chrome/common/extensions/background_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/incognito_handler.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
+#include "googleurl/src/gurl.h"
 
 using content::SiteInstance;
 using content::WebContents;
 
 // Since we have 2 ports for every channel, we just index channels by half the
 // port ID.
 #define GET_CHANNEL_ID(port_id) ((port_id) / 2)
 #define GET_CHANNEL_OPENER_ID(channel_id) ((channel_id) * 2)
 #define GET_CHANNEL_RECEIVERS_ID(channel_id) ((channel_id) * 2 + 1)
 
@@ skipping 14 matching lines @@
     "Native Messaging is not supported on this platform.";
 }
 
 struct MessageService::MessageChannel {
   scoped_ptr<MessagePort> opener;
   scoped_ptr<MessagePort> receiver;
 };
 
 struct MessageService::OpenChannelParams {
   content::RenderProcessHost* source;
-  std::string tab_json;
+  DictionaryValue source_tab;
   scoped_ptr<MessagePort> receiver;
   int receiver_port_id;
   std::string source_extension_id;
   std::string target_extension_id;
+  GURL source_url;
   std::string channel_name;
 
   // Takes ownership of receiver.
   OpenChannelParams(content::RenderProcessHost* source,
-                    const std::string& tab_json,
+                    scoped_ptr<DictionaryValue> source_tab,
                     MessagePort* receiver,
                     int receiver_port_id,
                     const std::string& source_extension_id,
                     const std::string& target_extension_id,
+                    const GURL& source_url,
                     const std::string& channel_name)
       : source(source),
-        tab_json(tab_json),
         receiver(receiver),
         receiver_port_id(receiver_port_id),
         source_extension_id(source_extension_id),
         target_extension_id(target_extension_id),
-        channel_name(channel_name) {}
+        source_url(source_url),
+        channel_name(channel_name) {
+    if (source_tab)
+      this->source_tab.Swap(source_tab.get());
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(OpenChannelParams);
 };
 
 namespace {
 
 static base::StaticAtomicSequenceNumber g_next_channel_id;
 
 static content::RenderProcessHost* GetExtensionProcess(
     Profile* profile, const std::string& extension_id) {
   SiteInstance* site_instance =
       extensions::ExtensionSystem::Get(profile)->process_manager()->
@@ skipping 44 matching lines @@
 
 MessageService::~MessageService() {
   STLDeleteContainerPairSecondPointers(channels_.begin(), channels_.end());
   channels_.clear();
 }
 
 void MessageService::OpenChannelToExtension(
     int source_process_id, int source_routing_id, int receiver_port_id,
     const std::string& source_extension_id,
     const std::string& target_extension_id,
+    const GURL& source_url,
     const std::string& channel_name) {
   content::RenderProcessHost* source =
       content::RenderProcessHost::FromID(source_process_id);
   if (!source)
     return;
   Profile* profile = Profile::FromBrowserContext(source->GetBrowserContext());
 
+  const Extension* target_extension = ExtensionSystem::Get(profile)->
+      extension_service()->extensions()->GetByID(target_extension_id);
+  if (!target_extension) {
+    // Treat it as a disconnect.
+    ExtensionMessagePort port(source, MSG_ROUTING_CONTROL, std::string());
+    port.DispatchOnDisconnect(GET_OPPOSITE_PORT_ID(receiver_port_id),
+                              kReceivingEndDoesntExistError);
+    return;
+  }
+
   // Note: we use the source's profile here. If the source is an incognito
   // process, we will use the incognito EPM to find the right extension process,
   // which depends on whether the extension uses spanning or split mode.
   MessagePort* receiver = new ExtensionMessagePort(
       GetExtensionProcess(profile, target_extension_id), MSG_ROUTING_CONTROL,
       target_extension_id);
   WebContents* source_contents = tab_util::GetWebContentsByID(
       source_process_id, source_routing_id);
 
   // Include info about the opener's tab (if it was a tab).
-  std::string tab_json = "null";
-  if (source_contents) {
-    scoped_ptr<DictionaryValue> tab_value(ExtensionTabUtil::CreateTabValue(
-        source_contents));
-    base::JSONWriter::Write(tab_value.get(), &tab_json);
+  scoped_ptr<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;
   }
 
-  OpenChannelParams* params = new OpenChannelParams(source, tab_json, receiver,
+  OpenChannelParams* params = new OpenChannelParams(source,
+                                                    source_tab.Pass(),
+                                                    receiver,
                                                     receiver_port_id,
                                                     source_extension_id,
                                                     target_extension_id,
+                                                    source_url_for_tab,
                                                     channel_name);
 
   // The target might be a lazy background page. In that case, we have to check
   // if it is loaded and ready, and if not, queue up the task and load the
   // page.
-  if (MaybeAddPendingOpenChannelTask(profile, params)) {
+  if (MaybeAddPendingOpenChannelTask(profile, target_extension, params)) {
     return;
   }
 
-  OpenChannelImpl(scoped_ptr<OpenChannelParams>(params));
+  OpenChannelImpl(make_scoped_ptr(params));
 }
 
 void MessageService::OpenChannelToNativeApp(
     int source_process_id,
     int source_routing_id,
     int receiver_port_id,
     const std::string& source_extension_id,
     const std::string& native_app_name) {
   content::RenderProcessHost* source =
       content::RenderProcessHost::FromID(source_process_id);
@@ skipping 12 matching lines @@
         APIPermission::kNativeMessaging);
   }
 
   if (!has_permission) {
     ExtensionMessagePort port(source, MSG_ROUTING_CONTROL, std::string());
     port.DispatchOnDisconnect(GET_OPPOSITE_PORT_ID(receiver_port_id),
                               kMissingPermissionError);
     return;
   }
 
-  WebContents* source_contents = tab_util::GetWebContentsByID(
-      source_process_id, source_routing_id);
-
-  // Include info about the opener's tab (if it was a tab).
-  std::string tab_json = "null";
-  if (source_contents) {
-    scoped_ptr<DictionaryValue> tab_value(ExtensionTabUtil::CreateTabValue(
-        source_contents));
-    base::JSONWriter::Write(tab_value.get(), &tab_json);
-  }
-
   scoped_ptr<MessageChannel> channel(new MessageChannel());
   channel->opener.reset(new ExtensionMessagePort(source, MSG_ROUTING_CONTROL,
                                                  source_extension_id));
 
   scoped_ptr<NativeMessageProcessHost> native_process =
       NativeMessageProcessHost::Create(
           base::WeakPtr<NativeMessageProcessHost::Client>(
               weak_factory_.GetWeakPtr()),
           source_extension_id, native_app_name, receiver_port_id);
 
@@ skipping 41 matching lines @@
 
   if (contents && contents->GetController().NeedsReload()) {
     // The tab isn't loaded yet. Don't attempt to connect. Treat this as a
     // disconnect.
     ExtensionMessagePort port(source, MSG_ROUTING_CONTROL, extension_id);
     port.DispatchOnDisconnect(GET_OPPOSITE_PORT_ID(receiver_port_id),
                               kReceivingEndDoesntExistError);
     return;
   }
 
-  WebContents* source_contents = tab_util::GetWebContentsByID(
-      source_process_id, source_routing_id);
-
-  // Include info about the opener's tab (if it was a tab).
-  std::string tab_json = "null";
-  if (source_contents) {
-    scoped_ptr<DictionaryValue> tab_value(ExtensionTabUtil::CreateTabValue(
-        source_contents));
-    base::JSONWriter::Write(tab_value.get(), &tab_json);
-  }
-
-  scoped_ptr<OpenChannelParams> params(new OpenChannelParams(source, tab_json,
-                                                             receiver.release(),
-                                                             receiver_port_id,
-                                                             extension_id,
-                                                             extension_id,
-                                                             channel_name));
+  scoped_ptr<OpenChannelParams> params(new OpenChannelParams(
+        source,
+        scoped_ptr<DictionaryValue>(),  // Source tab doesn't make sense for
+                                        // opening to tabs.
+        receiver.release(),
+        receiver_port_id,
+        extension_id,
+        extension_id,
+        GURL(),  // Source URL doesn't make sense for opening to tabs.
+        channel_name));
   OpenChannelImpl(params.Pass());
 }
 
 bool MessageService::OpenChannelImpl(scoped_ptr<OpenChannelParams> params) {
   if (!params->source)
     return false;  // Closed while in flight.
 
-  if (!params->receiver.get() || !params->receiver->GetRenderProcessHost()) {
+  if (!params->receiver || !params->receiver->GetRenderProcessHost()) {
     // Treat it as a disconnect.
     ExtensionMessagePort port(
         params->source, MSG_ROUTING_CONTROL, std::string());
     port.DispatchOnDisconnect(GET_OPPOSITE_PORT_ID(params->receiver_port_id),
                               kReceivingEndDoesntExistError);
     return false;
   }
 
   // Add extra paranoid CHECKs, since we have crash reports of this being NULL.
   // http://code.google.com/p/chromium/issues/detail?id=19067
   CHECK(params->receiver->GetRenderProcessHost());
 
   MessageChannel* channel(new MessageChannel);
   channel->opener.reset(new ExtensionMessagePort(params->source,
                                                  MSG_ROUTING_CONTROL,
                                                  params->source_extension_id));
   channel->receiver.reset(params->receiver.release());
 
   CHECK(channel->receiver->GetRenderProcessHost());
 
   AddChannel(channel, params->receiver_port_id);
 
   CHECK(channel->receiver->GetRenderProcessHost());
 
   // Send the connect event to the receiver.  Give it the opener's port ID (the
   // opener has the opposite port ID).
   channel->receiver->DispatchOnConnect(params->receiver_port_id,
-                                       params->channel_name, params->tab_json,
+                                       params->channel_name,
+                                       params->source_tab,
                                        params->source_extension_id,
-                                       params->target_extension_id);
+                                       params->target_extension_id,
+                                       params->source_url);
 
   // Keep both ends of the channel alive until the channel is closed.
   channel->opener->IncrementLazyKeepaliveCount();
   channel->receiver->IncrementLazyKeepaliveCount();
   return true;
 }
 
 void MessageService::AddChannel(MessageChannel* channel, int receiver_port_id) {
   int channel_id = GET_CHANNEL_ID(receiver_port_id);
   CHECK(channels_.find(channel_id) == channels_.end());
@@ skipping 110 matching lines @@
                        std::string(), notify_other_port);
     } else if (receiver_process == process) {
       CloseChannelImpl(current, GET_CHANNEL_RECEIVERS_ID(current->first),
                        std::string(), notify_other_port);
     }
   }
 }
 
 bool MessageService::MaybeAddPendingOpenChannelTask(
     Profile* profile,
+    const Extension* extension,
     OpenChannelParams* params) {
-  ExtensionService* service = profile->GetExtensionService();
-  const std::string& extension_id = params->target_extension_id;
-  const Extension* extension = service->extensions()->GetByID(extension_id);
-  if (extension && BackgroundInfo::HasLazyBackgroundPage(extension)) {
-    // If the extension uses spanning incognito mode, make sure we're always
-    // using the original profile since that is what the extension process
-    // will use.
-    if (!IncognitoInfo::IsSplitMode(extension))
-      profile = profile->GetOriginalProfile();
+  if (!BackgroundInfo::HasLazyBackgroundPage(extension))
+    return false;
 
-    if (lazy_background_task_queue_->ShouldEnqueueTask(profile, extension)) {
-      pending_channels_[GET_CHANNEL_ID(params->receiver_port_id)] =
-          PendingChannel(profile, extension_id);
-      scoped_ptr<OpenChannelParams> scoped_params(params);
-      lazy_background_task_queue_->AddPendingTask(profile, extension_id,
-          base::Bind(&MessageService::PendingOpenChannel,
-                     weak_factory_.GetWeakPtr(), base::Passed(&scoped_params),
-                     params->source->GetID()));
-      return true;
-    }
-  }
+  // If the extension uses spanning incognito mode, make sure we're always
+  // using the original profile since that is what the extension process
+  // will use.
+  if (!IncognitoInfo::IsSplitMode(extension))
+    profile = profile->GetOriginalProfile();
 
-  return false;
+  if (!lazy_background_task_queue_->ShouldEnqueueTask(profile, extension))
+    return false;
+
+  pending_channels_[GET_CHANNEL_ID(params->receiver_port_id)] =
+      PendingChannel(profile, extension->id());
+  scoped_ptr<OpenChannelParams> scoped_params(params);
+  lazy_background_task_queue_->AddPendingTask(profile, extension->id(),
+      base::Bind(&MessageService::PendingOpenChannel,
+                 weak_factory_.GetWeakPtr(), base::Passed(&scoped_params),
+                 params->source->GetID()));
+  return true;
 }
 
 void MessageService::PendingOpenChannel(scoped_ptr<OpenChannelParams> params,
                                         int source_process_id,
                                         ExtensionHost* host) {
   if (!host)
     return;  // TODO(mpcomplete): notify source of disconnect?
 
   // Re-lookup the source process since it may no longer be valid.
   content::RenderProcessHost* source =
       content::RenderProcessHost::FromID(source_process_id);
   if (!source)
     return;
 
   params->source = source;
   params->receiver.reset(new ExtensionMessagePort(host->render_process_host(),
                                                   MSG_ROUTING_CONTROL,
                                                   params->target_extension_id));
   OpenChannelImpl(params.Pass());
 }
 
 }  // namespace extensions