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

chrome/browser/net/chrome_url_request_context.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/net/chrome_url_request_context.h"
 
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/string_number_conversions.h"
@@ skipping 307 matching lines @@
   net::SetURLRequestContextForOCSP(context);
 #endif
 
   context->set_net_log(io_thread_globals->net_log.get());
   return context;
 }
 
 // Factory that creates the ChromeURLRequestContext for extensions.
 class FactoryForExtensions : public ChromeURLRequestContextFactory {
  public:
-  FactoryForExtensions(Profile* profile, const FilePath& cookie_store_path)
+  FactoryForExtensions(Profile* profile, const FilePath& cookie_store_path,
+                       bool incognito)
       : ChromeURLRequestContextFactory(profile),
-        cookie_store_path_(cookie_store_path) {
+        cookie_store_path_(cookie_store_path),
+        incognito_(incognito) {
   }
 
   virtual ChromeURLRequestContext* Create();
 
  private:
   FilePath cookie_store_path_;
+  bool incognito_;
 };
 
 ChromeURLRequestContext* FactoryForExtensions::Create() {
   ChromeURLRequestContext* context = new ChromeURLRequestContext;
   ApplyProfileParametersToContext(context);
 
   IOThread::Globals* io_thread_globals = io_thread()->globals();
 
-  // All we care about for extensions is the cookie store.
-  DCHECK(!cookie_store_path_.empty());
+  // All we care about for extensions is the cookie store. For incognito, we
+  // use a non-persistent cookie store.
+  scoped_refptr<SQLitePersistentCookieStore> cookie_db = NULL;
+  if (!incognito_) {
+    DCHECK(!cookie_store_path_.empty());
+    cookie_db = new SQLitePersistentCookieStore(cookie_store_path_);
+  }
 
-  scoped_refptr<SQLitePersistentCookieStore> cookie_db =
-      new SQLitePersistentCookieStore(cookie_store_path_);
   net::CookieMonster* cookie_monster =
       new net::CookieMonster(cookie_db.get(), NULL);
 
   // Enable cookies for extension URLs only.
   const char* schemes[] = {chrome::kExtensionScheme};
   cookie_monster->SetCookieableSchemes(schemes, 1);
   context->set_cookie_store(cookie_monster);
   // TODO(cbentzel): How should extensions handle HTTP Authentication?
   context->set_http_auth_handler_factory(
       io_thread_globals->http_auth_handler_factory.get());
@@ skipping 257 matching lines @@
                                       false);
 }
 
 // static
 ChromeURLRequestContextGetter*
 ChromeURLRequestContextGetter::CreateOriginalForExtensions(
     Profile* profile, const FilePath& cookie_store_path) {
   DCHECK(!profile->IsOffTheRecord());
   return new ChromeURLRequestContextGetter(
       profile,
-      new FactoryForExtensions(profile, cookie_store_path));
+      new FactoryForExtensions(profile, cookie_store_path, false));
 }
 
 // static
 ChromeURLRequestContextGetter*
 ChromeURLRequestContextGetter::CreateOffTheRecord(Profile* profile) {
   DCHECK(profile->IsOffTheRecord());
   return new ChromeURLRequestContextGetter(
       profile, new FactoryForOffTheRecord(profile));
 }
 
+// static
+ChromeURLRequestContextGetter*
+ChromeURLRequestContextGetter::CreateOffTheRecordForExtensions(
+    Profile* profile) {
+  DCHECK(profile->IsOffTheRecord());
+  return new ChromeURLRequestContextGetter(
+      profile, new FactoryForExtensions(profile, FilePath(), true));
+}
+
 void ChromeURLRequestContextGetter::CleanupOnUIThread() {
   CheckCurrentlyOnMainThread();
 
   if (prefs_) {
     // Unregister for pref notifications.
     prefs_->RemovePrefObserver(prefs::kAcceptLanguages, this);
     prefs_->RemovePrefObserver(prefs::kDefaultCharset, this);
     prefs_ = NULL;
   }
 }
@@ skipping 143 matching lines @@
     return iter->second->path;
   else
     return FilePath();
 }
 
 bool ChromeURLRequestContext::ExtensionHasWebExtent(const std::string& id) {
   ExtensionInfoMap::iterator iter = extension_info_.find(id);
   return iter != extension_info_.end() && !iter->second->extent.is_empty();
 }
 
+bool ChromeURLRequestContext::ExtensionCanLoadInIncognito(
+    const std::string& id) {
+  ExtensionInfoMap::iterator iter = extension_info_.find(id);
+  // Only split-mode extensions can load in incognito profiles.
+  return iter != extension_info_.end() && iter->second->incognito_split_mode;
+}
+
 std::string ChromeURLRequestContext::GetDefaultLocaleForExtension(
     const std::string& id) {
   ExtensionInfoMap::iterator iter = extension_info_.find(id);
   std::string result;
   if (iter != extension_info_.end())
     result = iter->second->default_locale;
 
   return result;
 }
 
@@ skipping 34 matching lines @@
                    permission_name) != api_permissions.end();
 }
 
 const std::string& ChromeURLRequestContext::GetUserAgent(
     const GURL& url) const {
   return webkit_glue::GetUserAgent(url);
 }
 
 void ChromeURLRequestContext::OnNewExtensions(const std::string& id,
                                               ExtensionInfo* info) {
-  if (!is_off_the_record_)
-    extension_info_[id] = linked_ptr<ExtensionInfo>(info);
+  extension_info_[id] = linked_ptr<ExtensionInfo>(info);
 }
 
 void ChromeURLRequestContext::OnUnloadedExtension(const std::string& id) {
   CheckCurrentlyOnIOThread();
-  if (is_off_the_record_)
-    return;
   ExtensionInfoMap::iterator iter = extension_info_.find(id);
   if (iter != extension_info_.end()) {
     extension_info_.erase(iter);
   } else {
     // NOTE: This can currently happen if we receive multiple unload
     // notifications, e.g. setting incognito-enabled state for a
     // disabled extension (e.g., via sync).  See
     // http://code.google.com/p/chromium/issues/detail?id=50582 .
     NOTREACHED() << id;
   }
@@ skipping 96 matching lines @@
     const ExtensionList* extensions =
         profile->GetExtensionsService()->extensions();
     for (ExtensionList::const_iterator iter = extensions->begin();
         iter != extensions->end(); ++iter) {
       extension_info_[(*iter)->id()] =
           linked_ptr<ChromeURLRequestContext::ExtensionInfo>(
               new ChromeURLRequestContext::ExtensionInfo(
                   (*iter)->name(),
                   (*iter)->path(),
                   (*iter)->default_locale(),
+                  (*iter)->incognito_split_mode(),
                   (*iter)->web_extent(),
                   (*iter)->GetEffectiveHostPermissions(),
                   (*iter)->api_permissions()));
     }
   }
 
   if (profile->GetUserScriptMaster())
     user_script_dir_path_ = profile->GetUserScriptMaster()->user_script_dir();
 
   ssl_config_service_ = profile->GetSSLConfigService();
@@ skipping 74 matching lines @@
       prefs::kProxyAutoDetect));
 
   if (pref_service->HasPrefPath(prefs::kProxyBypassList)) {
     std::string proxy_bypass =
         pref_service->GetString(prefs::kProxyBypassList);
     proxy_config->proxy_rules().bypass_rules.ParseFromString(proxy_bypass);
   }
 
   return proxy_config;
 }