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

chrome/browser/extensions/extension_function_dispatcher.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_function_dispatcher.h"
 
 #include <map>
 
 #include "base/process_util.h"
 #include "base/singleton.h"
@@ skipping 365 matching lines @@
   }
 
   // Update the extension permissions. Doing this each time we create an EFD
   // ensures that new processes are informed of permissions for newly installed
   // extensions.
   render_view_host->Send(new ViewMsg_Extension_SetAPIPermissions(
       extension->id(), extension->api_permissions()));
   render_view_host->Send(new ViewMsg_Extension_SetHostPermissions(
       extension->url(), extension->host_permissions()));
   render_view_host->Send(new ViewMsg_Extension_ExtensionSetIncognitoEnabled(
-      extension->id(), incognito_enabled));
+      extension->id(), incognito_enabled, extension->incognito_split_mode()));
 
   NotificationService::current()->Notify(
       NotificationType::EXTENSION_FUNCTION_DISPATCHER_CREATED,
       Source<Profile>(profile_),
       Details<ExtensionFunctionDispatcher>(this));
 }
 
 ExtensionFunctionDispatcher::~ExtensionFunctionDispatcher() {
   peer_->dispatcher_ = NULL;
 
   NotificationService::current()->Notify(
       NotificationType::EXTENSION_FUNCTION_DISPATCHER_DESTROYED,
       Source<Profile>(profile_),
       Details<ExtensionFunctionDispatcher>(this));
 }
 
 Browser* ExtensionFunctionDispatcher::GetCurrentBrowser(
     bool include_incognito) {
   Browser* browser = delegate_->GetBrowser();
 
-  // If the delegate has an associated browser and that browser is in the right
-  // incognito state, we can return it.
-  if (browser) {
-    if (include_incognito || !browser->profile()->IsOffTheRecord())
-      return browser;
-  }
+  // If the delegate has an associated browser, that is always the right answer.
+  if (browser)
+    return browser;
 
-  // Otherwise, try to default to a reasonable browser.
+  // Otherwise, try to default to a reasonable browser. If |include_incognito|
+  // is true, we will also search browsers in the incognito version of this
+  // profile. Note that the profile may already be incognito, in which case
+  // we will search the incognito version only, regardless of the value of
+  // |include_incognito|.
   Profile* profile = render_view_host()->process()->profile();
-
-  // Make sure we don't return an incognito browser without proper access.
-  if (!include_incognito)
-    profile = profile->GetOriginalProfile();
-
   browser = BrowserList::FindBrowserWithType(profile, Browser::TYPE_NORMAL,
                                              include_incognito);
 
   // NOTE(rafaelw): This can return NULL in some circumstances. In particular,
   // a background_page onload chrome.tabs api call can make it into here
   // before the browser is sufficiently initialized to return here.
   // A similar situation may arise during shutdown.
   // TODO(rafaelw): Delay creation of background_page until the browser
   // is available. http://code.google.com/p/chromium/issues/detail?id=13284
   return browser;
 }
 
 void ExtensionFunctionDispatcher::HandleRequest(
     const ViewHostMsg_DomMessage_Params& params) {
   scoped_refptr<ExtensionFunction> function(
       FactoryRegistry::instance()->NewFunction(params.name));
   function->set_dispatcher_peer(peer_);
   function->set_profile(profile_);
   function->set_extension_id(extension_id());
   function->SetArgs(&params.arguments);
   function->set_source_url(params.source_url);
   function->set_request_id(params.request_id);
   function->set_has_callback(params.has_callback);
   function->set_user_gesture(params.user_gesture);
   ExtensionsService* service = profile()->GetExtensionsService();
   DCHECK(service);
   Extension* extension = service->GetExtensionById(extension_id(), false);
   DCHECK(extension);
-  function->set_include_incognito(service->IsIncognitoEnabled(extension));
+  function->set_include_incognito(service->IsIncognitoEnabled(extension) &&
+                                  !extension->incognito_split_mode());
 
   ExtensionsQuotaService* quota = service->quota_service();
   if (quota->Assess(extension_id(), function, &params.arguments,
                     base::TimeTicks::Now())) {
     // See crbug.com/39178.
     ExternalProtocolHandler::PermitLaunchUrl();
 
     function->Run();
   } else {
     render_view_host_->SendExtensionResponse(function->request_id(), false,
@@ skipping 17 matching lines @@
   } else {
     NOTREACHED();
     base::KillProcess(render_view_host_->process()->GetHandle(),
                       ResultCodes::KILLED_BAD_MESSAGE, false);
   }
 }
 
 Profile* ExtensionFunctionDispatcher::profile() {
   return profile_;
 }