Remove the Extensions URLRequestContext

content/browser/storage_partition_impl.cc

 // Copyright (c) 2012 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 "content/browser/storage_partition_impl.h"
 
 #include "base/sequenced_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/browser_main_loop.h"
 #include "content/browser/fileapi/browser_file_system_helper.h"
 #include "content/browser/gpu/shader_disk_cache.h"
+#include "content/browser/net/cookie_store_map.h"
 #include "content/common/dom_storage/dom_storage_types.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/dom_storage_context.h"
 #include "content/public/browser/indexed_db_context.h"
 #include "content/public/browser/local_storage_usage_info.h"
 #include "content/public/browser/session_storage_usage_info.h"
+#include "content/public/common/url_constants.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "webkit/browser/database/database_tracker.h"
 #include "webkit/browser/quota/quota_manager.h"
 
 namespace content {
 
 namespace {
 
 int GenerateQuotaClientMask(uint32 remove_mask) {
   int quota_client_mask = 0;
 
   if (remove_mask & StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS)
     quota_client_mask |= quota::QuotaClient::kFileSystem;
   if (remove_mask & StoragePartition::REMOVE_DATA_MASK_WEBSQL)
     quota_client_mask |= quota::QuotaClient::kDatabase;
   if (remove_mask & StoragePartition::REMOVE_DATA_MASK_APPCACHE)
     quota_client_mask |= quota::QuotaClient::kAppcache;
   if (remove_mask & StoragePartition::REMOVE_DATA_MASK_INDEXEDDB)
     quota_client_mask |= quota::QuotaClient::kIndexedDatabase;
 
   return quota_client_mask;
 }
 
-void OnClearedCookies(const base::Closure& callback, int num_deleted) {
-  // The final callback needs to happen from UI thread.
-  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        base::Bind(&OnClearedCookies, callback, num_deleted));
-    return;
-  }
-
-  callback.Run();
-}
-
-void ClearCookiesOnIOThread(
-    const scoped_refptr<net::URLRequestContextGetter>& rq_context,
-    const base::Time begin,
-    const base::Time end,
-    const GURL& remove_origin,
-    const base::Closure& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  net::CookieStore* cookie_store = rq_context->
-      GetURLRequestContext()->cookie_store();
-  if (remove_origin.is_empty()) {
-    cookie_store->GetCookieMonster()->DeleteAllCreatedBetweenAsync(
-        begin,
-        end,
-        base::Bind(&OnClearedCookies, callback));
-  } else {
-    cookie_store->GetCookieMonster()->DeleteAllCreatedBetweenForHostAsync(
-        begin,
-        end,
-        remove_origin, base::Bind(&OnClearedCookies, callback));
-  }
-}
-
 void OnQuotaManagedOriginDeleted(const GURL& origin,
                                  quota::StorageType type,
                                  size_t* origins_to_delete_count,
                                  const base::Closure& callback,
                                  quota::QuotaStatusCode status) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK_GT(*origins_to_delete_count, 0u);
   if (status != quota::kQuotaStatusOk) {
     DLOG(ERROR) << "Couldn't remove data of type " << type << " for origin "
                 << origin << ". Status: " << status;
@@ skipping 152 matching lines @@
       : callback(callback), task_count(0) {
   }
 
   void IncrementTaskCountOnUI();
   void DecrementTaskCountOnUI();
 
   void ClearDataOnUIThread(uint32 remove_mask,
                            uint32 quota_storage_remove_mask,
                            const GURL& remove_origin,
                            const base::FilePath& path,
-                           net::URLRequestContextGetter* rq_context,
+                           CookieStoreMap* cookie_store_map,
                            DOMStorageContextWrapper* dom_storage_context,
                            quota::QuotaManager* quota_manager,
                            WebRTCIdentityStore* webrtc_identity_store,
                            const base::Time begin,
                            const base::Time end);
 
   // Accessed on UI thread.
   const base::Closure callback;
   // Accessed on UI thread.
   int task_count;
@@ skipping 15 matching lines @@
 }
 
 StoragePartitionImpl::StoragePartitionImpl(
     const base::FilePath& partition_path,
     quota::QuotaManager* quota_manager,
     ChromeAppCacheService* appcache_service,
     fileapi::FileSystemContext* filesystem_context,
     webkit_database::DatabaseTracker* database_tracker,
     DOMStorageContextWrapper* dom_storage_context,
     IndexedDBContextImpl* indexed_db_context,
+    scoped_ptr<CookieStoreMap> cookie_store_map,
     WebRTCIdentityStore* webrtc_identity_store)
     : partition_path_(partition_path),
       quota_manager_(quota_manager),
       appcache_service_(appcache_service),
       filesystem_context_(filesystem_context),
       database_tracker_(database_tracker),
       dom_storage_context_(dom_storage_context),
       indexed_db_context_(indexed_db_context),
-      webrtc_identity_store_(webrtc_identity_store) {}
+      cookie_store_map_(cookie_store_map.Pass()),
+      webrtc_identity_store_(webrtc_identity_store) {
+}
 
 StoragePartitionImpl::~StoragePartitionImpl() {
   // These message loop checks are just to avoid leaks in unittests.
   if (GetDatabaseTracker() &&
       BrowserThread::IsMessageLoopValid(BrowserThread::FILE)) {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(&webkit_database::DatabaseTracker::Shutdown,
                    GetDatabaseTracker()));
   }
 
   if (GetFileSystemContext())
     GetFileSystemContext()->Shutdown();
 
   if (GetDOMStorageContext())
     GetDOMStorageContext()->Shutdown();
 }
 
 // TODO(ajwong): Break the direct dependency on |context|. We only
 // need 3 pieces of info from it.
 StoragePartitionImpl* StoragePartitionImpl::Create(
     BrowserContext* context,
     bool in_memory,
-    const base::FilePath& partition_path) {
+    const base::FilePath& partition_path,
+    scoped_ptr<CookieStoreMap> cookie_store_map) {
   // Ensure that these methods are called on the UI thread, except for
   // unittests where a UI thread might not have been created.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          !BrowserThread::IsMessageLoopValid(BrowserThread::UI));
 
   // All of the clients have to be created and registered with the
   // QuotaManager prior to the QuotaManger being used. We do them
   // all together here prior to handing out a reference to anything
   // that utilizes the QuotaManager.
   scoped_refptr<quota::QuotaManager> quota_manager = new quota::QuotaManager(
@@ skipping 43 matching lines @@
   scoped_refptr<WebRTCIdentityStore> webrtc_identity_store(
       new WebRTCIdentityStore(path, context->GetSpecialStoragePolicy()));
 
   return new StoragePartitionImpl(partition_path,
                                   quota_manager.get(),
                                   appcache_service.get(),
                                   filesystem_context.get(),
                                   database_tracker.get(),
                                   dom_storage_context.get(),
                                   indexed_db_context.get(),
+                                  cookie_store_map.Pass(),
                                   webrtc_identity_store.get());
 }
 
 base::FilePath StoragePartitionImpl::GetPath() {
   return partition_path_;
 }
 
 net::URLRequestContextGetter* StoragePartitionImpl::GetURLRequestContext() {
   return url_request_context_.get();
 }
@@ skipping 24 matching lines @@
 }
 
 IndexedDBContextImpl* StoragePartitionImpl::GetIndexedDBContext() {
   return indexed_db_context_.get();
 }
 
 void StoragePartitionImpl::ClearDataImpl(
     uint32 remove_mask,
     uint32 quota_storage_remove_mask,
     const GURL& remove_origin,
-    net::URLRequestContextGetter* rq_context,
     const base::Time begin,
     const base::Time end,
     const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DataDeletionHelper* helper = new DataDeletionHelper(callback);
   // |helper| deletes itself when done in
   // DataDeletionHelper::DecrementTaskCountOnUI().
   helper->ClearDataOnUIThread(
       remove_mask, quota_storage_remove_mask, remove_origin,
-      GetPath(), rq_context, dom_storage_context_, quota_manager_,
+      GetPath(), cookie_store_map_.get(), dom_storage_context_, quota_manager_,
       webrtc_identity_store_, begin, end);
 }
 
 void StoragePartitionImpl::
     QuotaManagedDataDeletionHelper::IncrementTaskCountOnIO() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   ++task_count;
 }
 
 void StoragePartitionImpl::
@@ skipping 92 matching lines @@
     callback.Run();
     delete this;
   }
 }
 
 void StoragePartitionImpl::DataDeletionHelper::ClearDataOnUIThread(
     uint32 remove_mask,
     uint32 quota_storage_remove_mask,
     const GURL& remove_origin,
     const base::FilePath& path,
-    net::URLRequestContextGetter* rq_context,
+    CookieStoreMap* cookie_store_map,
     DOMStorageContextWrapper* dom_storage_context,
     quota::QuotaManager* quota_manager,
     WebRTCIdentityStore* webrtc_identity_store,
     const base::Time begin,
     const base::Time end) {
   DCHECK_NE(remove_mask, 0u);
   DCHECK(!callback.is_null());
 
   IncrementTaskCountOnUI();
   base::Closure decrement_callback = base::Bind(
       &DataDeletionHelper::DecrementTaskCountOnUI, base::Unretained(this));
 
   if (remove_mask & REMOVE_DATA_MASK_COOKIES) {
     // Handle the cookies.
     IncrementTaskCountOnUI();
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        base::Bind(&ClearCookiesOnIOThread,
-                   make_scoped_refptr(rq_context), begin, end, remove_origin,
-                   decrement_callback));
+    cookie_store_map->DeleteCookies(remove_origin, begin, end,
+                                    decrement_callback);
   }
 
   if (remove_mask & REMOVE_DATA_MASK_INDEXEDDB ||
       remove_mask & REMOVE_DATA_MASK_WEBSQL ||
       remove_mask & REMOVE_DATA_MASK_APPCACHE ||
       remove_mask & REMOVE_DATA_MASK_FILE_SYSTEMS) {
     IncrementTaskCountOnUI();
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&ClearQuotaManagedDataOnIOThread,
@@ skipping 38 matching lines @@
                    decrement_callback));
   }
 
   DecrementTaskCountOnUI();
 }
 
 
 void StoragePartitionImpl::ClearDataForOrigin(
     uint32 remove_mask,
     uint32 quota_storage_remove_mask,
-    const GURL& storage_origin,
-    net::URLRequestContextGetter* request_context_getter) {
+    const GURL& storage_origin) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   ClearDataImpl(remove_mask, quota_storage_remove_mask, storage_origin,
-                request_context_getter, base::Time(), base::Time::Max(),
-                base::Bind(&base::DoNothing));
+                base::Time(), base::Time::Max(), base::Bind(&base::DoNothing));
 }
 
 void StoragePartitionImpl::ClearDataForUnboundedRange(
     uint32 remove_mask,
     uint32 quota_storage_remove_mask) {
   ClearDataImpl(remove_mask, quota_storage_remove_mask, GURL(),
-                GetURLRequestContext(), base::Time(), base::Time::Max(),
-                base::Bind(&base::DoNothing));
+                base::Time(), base::Time::Max(), base::Bind(&base::DoNothing));
 }
 
 void StoragePartitionImpl::ClearDataForRange(uint32 remove_mask,
                                              uint32 quota_storage_remove_mask,
                                              const base::Time& begin,
                                              const base::Time& end,
                                              const base::Closure& callback) {
-  ClearDataImpl(remove_mask, quota_storage_remove_mask, GURL(),
-                GetURLRequestContext(), begin, end, callback);
+  ClearDataImpl(remove_mask, quota_storage_remove_mask, GURL(), begin, end,
+                callback);
 }
 
 WebRTCIdentityStore* StoragePartitionImpl::GetWebRTCIdentityStore() {
   return webrtc_identity_store_.get();
 }
 
+const CookieStoreMap& StoragePartitionImpl::GetCookieStoreMap() {
+  return *cookie_store_map_;
+}
+
 void StoragePartitionImpl::SetURLRequestContext(
     net::URLRequestContextGetter* url_request_context) {
   url_request_context_ = url_request_context;
 }
 
 void StoragePartitionImpl::SetMediaURLRequestContext(
     net::URLRequestContextGetter* media_url_request_context) {
   media_url_request_context_ = media_url_request_context;
 }
 
 }  // namespace content