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

chrome/browser/extensions/extensions_ui.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/extensions_ui.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/base64.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/thread.h"
 #include "base/version.h"
 #include "chrome/browser/browser.h"
+#include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/debugger/devtools_manager.h"
 #include "chrome/browser/debugger/devtools_toggle_action.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_disabled_infobar_delegate.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_message_service.h"
 #include "chrome/browser/extensions/extensions_service.h"
@@ skipping 80 matching lines @@
   localized_strings.SetString("getMoreExtensions",
       ASCIIToUTF16("<a href='") +
           ASCIIToUTF16(google_util::AppendGoogleLocaleParam(
               GURL(Extension::ChromeStoreURL())).spec()) + ASCIIToUTF16("'>") +
           l10n_util::GetStringUTF16(IDS_GET_MORE_EXTENSIONS) +
           ASCIIToUTF16("</a>"));
   localized_strings.SetString("extensionDisabled",
       l10n_util::GetStringUTF16(IDS_EXTENSIONS_DISABLED_EXTENSION));
   localized_strings.SetString("inDevelopment",
       l10n_util::GetStringUTF16(IDS_EXTENSIONS_IN_DEVELOPMENT));
+  localized_strings.SetString("viewIncognito",
+      l10n_util::GetStringUTF16(IDS_EXTENSIONS_VIEW_INCOGNITO));
   localized_strings.SetString("extensionId",
       l10n_util::GetStringUTF16(IDS_EXTENSIONS_ID));
   localized_strings.SetString("extensionVersion",
       l10n_util::GetStringUTF16(IDS_EXTENSIONS_VERSION));
   localized_strings.SetString("inspectViews",
       l10n_util::GetStringUTF16(IDS_EXTENSIONS_INSPECT_VIEWS));
   localized_strings.SetString("inspectPopupsInstructions",
       l10n_util::GetStringUTF16(IDS_EXTENSIONS_INSPECT_POPUPS_INSTRUCTIONS));
   localized_strings.SetString("disable",
       l10n_util::GetStringUTF16(IDS_EXTENSIONS_DISABLE));
@@ skipping 182 matching lines @@
 
   // Add the extensions to the results structure.
   ListValue *extensions_list = new ListValue();
 
   // Stores the icon resource for each of the extensions in extensions_list. We
   // build up a list of them here, then load them on the file thread in
   // ::LoadIcons().
   std::vector<ExtensionResource>* extension_icons =
       new std::vector<ExtensionResource>();
 
-  ExtensionProcessManager* process_manager =
-      extensions_service_->profile()->GetExtensionProcessManager();
   const ExtensionList* extensions = extensions_service_->extensions();
   for (ExtensionList::const_iterator extension = extensions->begin();
        extension != extensions->end(); ++extension) {
     if (ShouldShowExtension(*extension)) {
-      RenderProcessHost* process =
-          process_manager->GetExtensionProcess((*extension)->url());
       extensions_list->Append(CreateExtensionDetailValue(
           extensions_service_.get(),
           *extension,
-          GetActivePagesForExtension(process, *extension),
+          GetActivePagesForExtension(*extension),
           true));  // enabled
       extension_icons->push_back(PickExtensionIcon(*extension));
     }
   }
   extensions = extensions_service_->disabled_extensions();
   for (ExtensionList::const_iterator extension = extensions->begin();
        extension != extensions->end(); ++extension) {
     if (ShouldShowExtension(*extension)) {
-      RenderProcessHost* process =
-          process_manager->GetExtensionProcess((*extension)->url());
       extensions_list->Append(CreateExtensionDetailValue(
           extensions_service_.get(),
           *extension,
-          GetActivePagesForExtension(process, *extension),
+          GetActivePagesForExtension(*extension),
           false));  // enabled
       extension_icons->push_back(PickExtensionIcon(*extension));
     }
   }
   results->Set("extensions", extensions_list);
 
   bool developer_mode = dom_ui_->GetProfile()->GetPrefs()
       ->GetBoolean(prefs::kExtensionsUIDeveloperMode);
   results->SetBoolean("developerMode", developer_mode);
 
@@ skipping 473 matching lines @@
     DictionaryValue* view_value = new DictionaryValue;
     if (iter->url.scheme() == chrome::kExtensionScheme) {
       // No leading slash.
       view_value->SetString("path", iter->url.path().substr(1));
     } else {
       // For live pages, use the full URL.
       view_value->SetString("path", iter->url.spec());
     }
     view_value->SetInteger("renderViewId", iter->render_view_id);
     view_value->SetInteger("renderProcessId", iter->render_process_id);
+    view_value->SetBoolean("incognito", iter->incognito);
     views->Append(view_value);
   }
   extension_data->Set("views", views);
   extension_data->SetBoolean("hasPopupAction",
       extension->browser_action() || extension->page_action());
   extension_data->SetString("galleryUrl", extension->GalleryUrl().spec());
 
   return extension_data;
 }
 
 std::vector<ExtensionPage> ExtensionsDOMHandler::GetActivePagesForExtension(
-    RenderProcessHost* process,
     Extension* extension) {
   std::vector<ExtensionPage> result;
+
+  // Get the extension process's active views.
+  ExtensionProcessManager* process_manager =
+      extensions_service_->profile()->GetExtensionProcessManager();
+  GetActivePagesForExtensionProcess(
+      process_manager->GetExtensionProcess(extension->url()),
+      extension, &result);
+
+  // Repeat for the incognito process, if applicable.
+  if (extensions_service_->profile()->HasOffTheRecordProfile() &&
+      extension->incognito_split_mode()) {
+    ExtensionProcessManager* process_manager =
+        extensions_service_->profile()->GetOffTheRecordProfile()->
+            GetExtensionProcessManager();
+    GetActivePagesForExtensionProcess(
+        process_manager->GetExtensionProcess(extension->url()),
+        extension, &result);
+  }
+
+  return result;
+}
+
+void ExtensionsDOMHandler::GetActivePagesForExtensionProcess(
+    RenderProcessHost* process,
+    Extension* extension,
+    std::vector<ExtensionPage> *result) {
   if (!process)
-    return result;
+    return;
 
   RenderProcessHost::listeners_iterator iter = process->ListenersIterator();
   for (; !iter.IsAtEnd(); iter.Advance()) {
     const RenderWidgetHost* widget =
         static_cast<const RenderWidgetHost*>(iter.GetCurrentValue());
     DCHECK(widget);
     if (!widget || !widget->IsRenderView())
       continue;
     const RenderViewHost* host = static_cast<const RenderViewHost*>(widget);
     if (host == deleting_rvh_ ||
         ViewType::EXTENSION_POPUP == host->delegate()->GetRenderViewType())
       continue;
 
     GURL url = host->delegate()->GetURL();
     if (url.SchemeIs(chrome::kExtensionScheme)) {
       if (url.host() != extension->id())
         continue;
     } else if (!extension->web_extent().ContainsURL(url)) {
       continue;
     }
 
-    result.push_back(ExtensionPage(url, process->id(), host->routing_id()));
+    result->push_back(ExtensionPage(url, process->id(), host->routing_id(),
+                                    process->profile()->IsOffTheRecord()));
   }
-
-  return result;
 }
 
 ExtensionsDOMHandler::~ExtensionsDOMHandler() {
   if (pack_job_.get())
     pack_job_->ClearClient();
 
   if (icon_loader_.get())
     icon_loader_->Cancel();
 }
 
@@ skipping 21 matching lines @@
 // static
 RefCountedMemory* ExtensionsUI::GetFaviconResourceBytes() {
   return ResourceBundle::GetSharedInstance().
       LoadDataResourceBytes(IDR_PLUGIN);
 }
 
 // static
 void ExtensionsUI::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kExtensionsUIDeveloperMode, false);
 }