Add support for a "split" incognito behavior for extensions.

chrome/browser/extensions/extension_message_service.cc

 // Copyright (c) 2010 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/extension_message_service.h"
 
 #include "base/atomic_sequence_num.h"
 #include "base/json/json_writer.h"
 #include "base/stl_util-inl.h"
 #include "base/values.h"
@@ skipping 186 matching lines @@
     const std::string& event_name) {
   return (listeners_.find(event_name) != listeners_.end() &&
           !listeners_[event_name].empty());
 }
 
 void ExtensionMessageService::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 std::string& channel_name) {
-  if (!profile_)
-    return;
-
   RenderProcessHost* source = RenderProcessHost::FromID(source_process_id);
   if (!source)
     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(
-      profile_->GetExtensionProcessManager()->GetExtensionProcess(
+      source->profile()->GetExtensionProcessManager()->GetExtensionProcess(
           target_extension_id),
       MSG_ROUTING_CONTROL);
   TabContents* source_contents = tab_util::GetTabContentsByID(
       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));
@@ skipping 88 matching lines @@
     const std::string& extension_id, const std::string& channel_name,
     const std::string& tab_json, IPC::Message::Sender* source) {
   DCHECK(profile_);
 
   int port1_id = -1;
   int port2_id = -1;
   // Create a channel ID for both sides of the channel.
   AllocatePortIdPair(&port1_id, &port2_id);
 
   MessagePort receiver(
-      profile_->GetExtensionProcessManager()->
-          GetExtensionProcess(extension_id),
+      profile_->GetExtensionProcessManager()->GetExtensionProcess(extension_id),
       MSG_ROUTING_CONTROL);
   if (!OpenChannelImpl(source, tab_json, receiver, port2_id,
                        extension_id, extension_id, channel_name))
     return -1;
 
   return port1_id;
 }
 
 int ExtensionMessageService::OpenSpecialChannelToTab(
     const std::string& extension_id, const std::string& channel_name,
@@ skipping 50 matching lines @@
   // Figure out which port the ID corresponds to.
   int dest_port_id = GET_OPPOSITE_PORT_ID(source_port_id);
   const MessagePort& port = IS_OPENER_PORT_ID(dest_port_id) ?
       iter->second->opener : iter->second->receiver;
 
   DispatchOnMessage(port, message, dest_port_id);
 }
 
 void ExtensionMessageService::DispatchEventToRenderers(
     const std::string& event_name, const std::string& event_args,
-    bool has_incognito_data, const GURL& event_url) {
+    Profile* source_profile, const GURL& event_url) {
+  if (!profile_)
+    return;
+
+  // We don't expect to get events from a completely different profile.
+  DCHECK(!source_profile || profile_->IsSameProfile(source_profile));
+
   ListenerMap::iterator it = listeners_.find(event_name);
   if (it == listeners_.end())
     return;
 
   std::set<int>& pids = it->second;
 
   // Send the event only to renderers that are listening for it.
   for (std::set<int>::iterator pid = pids.begin(); pid != pids.end(); ++pid) {
     RenderProcessHost* renderer = RenderProcessHost::FromID(*pid);
     if (!renderer)
       continue;
     if (!ChildProcessSecurityPolicy::GetInstance()->
             HasExtensionBindings(*pid)) {
       // Don't send browser-level events to unprivileged processes.
       continue;
     }
 
-    DispatchEvent(
-        renderer, event_name, event_args, has_incognito_data, event_url);
+    // Is this event from a different profile than the renderer (ie, an
+    // incognito tab event sent to a normal process, or vice versa).
+    bool cross_profile =
+        source_profile && renderer->profile() != source_profile;
+    DispatchEvent(renderer, event_name, event_args, cross_profile, event_url);
   }
 }
 
 void ExtensionMessageService::DispatchEventToExtension(
     const std::string& extension_id,
     const std::string& event_name, const std::string& event_args,
-    bool has_incognito_data, const GURL& event_url) {
+    Profile* source_profile, const GURL& event_url) {
   DispatchEventToRenderers(GetPerExtensionEventName(event_name, extension_id),
-                           event_args, has_incognito_data, event_url);
+                           event_args, source_profile, event_url);
 }
 
 void ExtensionMessageService::Observe(NotificationType type,
                                       const NotificationSource& source,
                                       const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::RENDERER_PROCESS_TERMINATED:
     case NotificationType::RENDERER_PROCESS_CLOSED: {
       RenderProcessHost* renderer = Source<RenderProcessHost>(source).ptr();
       OnSenderClosed(renderer);
@@ skipping 29 matching lines @@
 
     if (current->second->opener.sender == sender) {
       CloseChannelImpl(current, GET_CHANNEL_OPENER_ID(current->first),
                        notify_other_port);
     } else if (current->second->receiver.sender == sender) {
       CloseChannelImpl(current, GET_CHANNEL_RECEIVERS_ID(current->first),
                        notify_other_port);
     }
   }
 }