Add a separate cookie store that's used for extensions....

chrome/browser/profile.cc

 // Copyright (c) 2006-2008 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/profile.h"
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
@@ skipping 16 matching lines @@
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/tab_restore_service.h"
 #include "chrome/browser/spellchecker.h"
 #include "chrome/browser/ssl/ssl_host_state.h"
 #include "chrome/browser/browser_theme_provider.h"
 #include "chrome/browser/visitedlink_master.h"
 #include "chrome/browser/webdata/web_data_service.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/net/cookie_monster_sqlite.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "grit/locale_settings.h"
 
 using base::Time;
 using base::TimeDelta;
 
 // Delay, in milliseconds, before we explicitly create the SessionService.
 static const int kCreateSessionServiceDelayMS = 500;
 
 // A pointer to the request context for the default profile.  See comments on
 // Profile::GetDefaultRequestContext.
 URLRequestContext* Profile::default_request_context_;
 
+static void CleanupRequestContext(ChromeURLRequestContext* context) {
+  if (context) {
+    context->CleanupOnUIThread();
+
+    // Clean up request context on IO thread.
+    g_browser_process->io_thread()->message_loop()->ReleaseSoon(FROM_HERE,
+                                                                context);
+  }
+}
+
 // static
 void Profile::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kSearchSuggestEnabled, true);
   prefs->RegisterBooleanPref(prefs::kSessionExitedCleanly, true);
   prefs->RegisterBooleanPref(prefs::kSafeBrowsingEnabled, true);
   // TODO(estade): IDS_SPELLCHECK_DICTIONARY should be an ASCII string.
   prefs->RegisterLocalizedStringPref(prefs::kSpellCheckDictionary,
       IDS_SPELLCHECK_DICTIONARY);
   prefs->RegisterBooleanPref(prefs::kEnableSpellCheck, true);
   prefs->RegisterBooleanPref(prefs::kEnableUserScripts, false);
@@ skipping 20 matching lines @@
 // OffTheRecordProfileImpl is a profile subclass that wraps an existing profile
 // to make it suitable for the off the record mode.
 //
 ////////////////////////////////////////////////////////////////////////////////
 class OffTheRecordProfileImpl : public Profile,
                                 public NotificationObserver {
  public:
   explicit OffTheRecordProfileImpl(Profile* real_profile)
       : profile_(real_profile),
         media_request_context_(NULL),
+        extensions_request_context_(NULL),
         start_time_(Time::Now()) {
     request_context_ = ChromeURLRequestContext::CreateOffTheRecord(this);
     request_context_->AddRef();
 
     extension_process_manager_.reset(new ExtensionProcessManager(this));
 
     // Register for browser close notifications so we can detect when the last
     // off-the-record window is closed, in which case we can clean our states
     // (cookies, downloads...).
     NotificationService::current()->AddObserver(
         this,
         NotificationType::BROWSER_CLOSED,
         NotificationService::AllSources());
   }
 
   virtual ~OffTheRecordProfileImpl() {
-    if (request_context_) {
-      request_context_->CleanupOnUIThread();
-
-      // Clean up request context on IO thread.
-      g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
-          NewRunnableMethod(request_context_,
-              &base::RefCountedThreadSafe<URLRequestContext>::Release));
-      request_context_ = NULL;
-    }
+    CleanupRequestContext(request_context_);
+    CleanupRequestContext(media_request_context_);
+    CleanupRequestContext(extensions_request_context_);
     NotificationService::current()->RemoveObserver(
         this,
         NotificationType::BROWSER_CLOSED,
         NotificationService::AllSources());
   }
 
   virtual FilePath GetPath() { return profile_->GetPath(); }
 
   virtual bool IsOffTheRecord() {
     return true;
@@ skipping 117 matching lines @@
       media_request_context_ =
           ChromeURLRequestContext::CreateOffTheRecordForMedia(
               this, cache_path);
       media_request_context_->AddRef();
 
       DCHECK(media_request_context_->cookie_store());
     }
     return media_request_context_;
   }
 
+  URLRequestContext* GetRequestContextForExtensions() {
+    if (!extensions_request_context_) {
+      extensions_request_context_ =
+          ChromeURLRequestContext::CreateOffTheRecordForExtensions(this);
+      extensions_request_context_->AddRef();
+
+      DCHECK(extensions_request_context_->cookie_store());
+    }
+
+    return extensions_request_context_;
+  }
+
   virtual SessionService* GetSessionService() {
     // Don't save any sessions when off the record.
     return NULL;
   }
 
   virtual void ShutdownSessionService() {
     // We don't allow a session service, nothing to do.
   }
 
   virtual bool HasSessionService() const {
@@ skipping 87 matching lines @@
  private:
   // The real underlying profile.
   Profile* profile_;
 
   // The context to use for requests made from this OTR session.
   ChromeURLRequestContext* request_context_;
 
   // The context for requests for media resources.
   ChromeURLRequestContext* media_request_context_;
 
+  ChromeURLRequestContext* extensions_request_context_;
+
   // The download manager that only stores downloaded items in memory.
   scoped_refptr<DownloadManager> download_manager_;
 
   // The download manager that only stores downloaded items in memory.
   scoped_refptr<BrowserThemeProvider> theme_provider_;
 
   // We don't want SSLHostState from the OTR profile to leak back to the main
   // profile because then the main profile would learn some of the host names
   // the user visited while OTR.
   scoped_ptr<SSLHostState> ssl_host_state_;
 
   // Extensions run in a different context in incognito mode.
   scoped_ptr<ExtensionProcessManager> extension_process_manager_;
 
   // Time we were started.
   Time start_time_;
 
   DISALLOW_EVIL_CONSTRUCTORS(OffTheRecordProfileImpl);
 };
 
 ProfileImpl::ProfileImpl(const FilePath& path)
     : path_(path),
       request_context_(NULL),
       media_request_context_(NULL),
+      extensions_request_context_(NULL),
       history_service_created_(false),
       created_web_data_service_(false),
       created_download_manager_(false),
       created_theme_provider_(false),
       start_time_(Time::Now()),
       spellchecker_(NULL),
       shutdown_session_service_(false) {
   DCHECK(!path.empty()) << "Using an empty path will attempt to write " <<
                             "profile files to the root directory!";
   create_session_service_timer_.Start(
@@ skipping 106 matching lines @@
 
   if (spellchecker_) {
     // The spellchecker must be deleted on the I/O thread. During testing, we
     // don't have an I/O thread.
     if (io_thread)
       io_thread->message_loop()->ReleaseSoon(FROM_HERE, spellchecker_);
     else
       spellchecker_->Release();
   }
 
-  if (request_context_) {
-    request_context_->CleanupOnUIThread();
+  if (default_request_context_ == request_context_)
+    default_request_context_ = NULL;
 
-    if (default_request_context_ == request_context_)
-      default_request_context_ = NULL;
-
-    // Clean up request context on IO thread.
-    g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
-        NewRunnableMethod(request_context_,
-            &base::RefCountedThreadSafe<URLRequestContext>::Release));
-    request_context_ = NULL;
-  }
-
-  if (media_request_context_) {
-    media_request_context_->CleanupOnUIThread();
-
-    // Clean up request context on IO thread.
-    g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
-        NewRunnableMethod(media_request_context_,
-            &base::RefCountedThreadSafe<URLRequestContext>::Release));
-    media_request_context_ = NULL;
-  }
+  CleanupRequestContext(request_context_);
+  CleanupRequestContext(media_request_context_);
+  CleanupRequestContext(extensions_request_context_);
 
   // HistoryService may call into the BookmarkModel, as such we need to
   // delete HistoryService before the BookmarkModel. The destructor for
   // HistoryService will join with HistoryService's backend thread so that
   // by the time the destructor has finished we're sure it will no longer call
   // into the BookmarkModel.
   history_service_ = NULL;
   bookmark_bar_model_.reset();
 
   MarkAsCleanShutdown();
@@ skipping 159 matching lines @@
     media_request_context_ = ChromeURLRequestContext::CreateOriginalForMedia(
         this, cache_path);
     media_request_context_->AddRef();
 
     DCHECK(media_request_context_->cookie_store());
   }
 
   return media_request_context_;
 }
 
+URLRequestContext* ProfileImpl::GetRequestContextForExtensions() {
+  if (!extensions_request_context_) {
+    FilePath cookie_path = GetPath();
+    cookie_path = cookie_path.Append(chrome::kExtensionsCookieFilename);
+
+    extensions_request_context_ =
+        ChromeURLRequestContext::CreateOriginalForExtensions(this, cookie_path);
+    extensions_request_context_->AddRef();
+
+    DCHECK(extensions_request_context_->cookie_store());
+  }
+
+  return extensions_request_context_;
+}
+
 HistoryService* ProfileImpl::GetHistoryService(ServiceAccessType sat) {
   if (!history_service_created_) {
     history_service_created_ = true;
     scoped_refptr<HistoryService> history(new HistoryService(this));
     if (!history->Init(GetPath(), GetBookmarkModel()))
       return NULL;
     history_service_.swap(history);
 
     // Send out the notification that the history service was created.
     NotificationService::current()->
@@ skipping 256 matching lines @@
 
 void ProfileImpl::StopCreateSessionServiceTimer() {
   create_session_service_timer_.Stop();
 }
 
 #ifdef CHROME_PERSONALIZATION
 ProfilePersonalization* ProfileImpl::GetProfilePersonalization() {
   return personalization_.get();
 }
 #endif