Move webkit/{browser,common}/dom_storage into content/

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/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 "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"
-#include "webkit/common/dom_storage/dom_storage_types.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;
@@ skipping 92 matching lines @@
 void ClearShaderCacheOnIOThread(const base::FilePath& path,
                                 const base::Time begin,
                                 const base::Time end,
                                 const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   ShaderCacheFactory::GetInstance()->ClearByPath(
       path, begin, end, base::Bind(&ClearedShaderCache, callback));
 }
 
 void OnLocalStorageUsageInfo(
-    const scoped_refptr<DOMStorageContextImpl>& dom_storage_context,
+    const scoped_refptr<DOMStorageContextWrapper>& dom_storage_context,
     const base::Time delete_begin,
     const base::Time delete_end,
     const base::Closure& callback,
-    const std::vector<dom_storage::LocalStorageUsageInfo>& infos) {
+    const std::vector<LocalStorageUsageInfo>& infos) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   for (size_t i = 0; i < infos.size(); ++i) {
     if (infos[i].last_modified >= delete_begin &&
         infos[i].last_modified <= delete_end) {
       dom_storage_context->DeleteLocalStorage(infos[i].origin);
     }
   }
   callback.Run();
 }
 
 void OnSessionStorageUsageInfo(
-    const scoped_refptr<DOMStorageContextImpl>& dom_storage_context,
+    const scoped_refptr<DOMStorageContextWrapper>& dom_storage_context,
     const base::Closure& callback,
-    const std::vector<dom_storage::SessionStorageUsageInfo>& infos) {
+    const std::vector<SessionStorageUsageInfo>& infos) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   for (size_t i = 0; i < infos.size(); ++i)
     dom_storage_context->DeleteSessionStorage(infos[i]);
 
   callback.Run();
 }
 
 void ClearLocalStorageOnUIThread(
-    const scoped_refptr<DOMStorageContextImpl>& dom_storage_context,
+    const scoped_refptr<DOMStorageContextWrapper>& dom_storage_context,
     const GURL& remove_origin,
     const base::Time begin,
     const base::Time end,
     const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!remove_origin.is_empty()) {
     dom_storage_context->DeleteLocalStorage(remove_origin);
     callback.Run();
     return;
   }
 
   dom_storage_context->GetLocalStorageUsage(
       base::Bind(&OnLocalStorageUsageInfo,
                  dom_storage_context, begin, end, callback));
 }
 
 void ClearSessionStorageOnUIThread(
-    const scoped_refptr<DOMStorageContextImpl>& dom_storage_context,
+    const scoped_refptr<DOMStorageContextWrapper>& dom_storage_context,
     const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   dom_storage_context->GetSessionStorageUsage(
       base::Bind(&OnSessionStorageUsageInfo, dom_storage_context, callback));
 }
 
 }  // namespace
 
 // Helper for deleting quota managed data from a partition.
@@ skipping 36 matching lines @@
   }
 
   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,
-                           DOMStorageContextImpl* dom_storage_context,
+                           DOMStorageContextWrapper* dom_storage_context,
                            quota::QuotaManager* quota_manager,
                            const base::Time begin,
                            const base::Time end);
 
   // Accessed on UI thread.
   const base::Closure callback;
   // Accessed on UI thread.
   int task_count;
 };
 
@@ skipping 11 matching lines @@
   helper->ClearDataOnIOThread(quota_manager, begin,
       remove_mask, quota_storage_remove_mask, remove_origin);
 }
 
 StoragePartitionImpl::StoragePartitionImpl(
     const base::FilePath& partition_path,
     quota::QuotaManager* quota_manager,
     ChromeAppCacheService* appcache_service,
     fileapi::FileSystemContext* filesystem_context,
     webkit_database::DatabaseTracker* database_tracker,
-    DOMStorageContextImpl* dom_storage_context,
+    DOMStorageContextWrapper* dom_storage_context,
     IndexedDBContextImpl* indexed_db_context,
     scoped_ptr<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.Pass()) {}
@@ skipping 44 matching lines @@
   scoped_refptr<webkit_database::DatabaseTracker> database_tracker =
       new webkit_database::DatabaseTracker(
           partition_path,
           in_memory,
           context->GetSpecialStoragePolicy(),
           quota_manager->proxy(),
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)
               .get());
 
   base::FilePath path = in_memory ? base::FilePath() : partition_path;
-  scoped_refptr<DOMStorageContextImpl> dom_storage_context =
-      new DOMStorageContextImpl(path, context->GetSpecialStoragePolicy());
+  scoped_refptr<DOMStorageContextWrapper> dom_storage_context =
+      new DOMStorageContextWrapper(path, context->GetSpecialStoragePolicy());
 
   // BrowserMainLoop may not be initialized in unit tests. Tests will
   // need to inject their own task runner into the IndexedDBContext.
   base::SequencedTaskRunner* idb_task_runner =
       BrowserThread::CurrentlyOn(BrowserThread::UI) &&
               BrowserMainLoop::GetInstance()
           ? BrowserMainLoop::GetInstance()->indexed_db_thread()
                 ->message_loop_proxy().get()
           : NULL;
   scoped_refptr<IndexedDBContextImpl> indexed_db_context =
@@ skipping 40 matching lines @@
 }
 
 fileapi::FileSystemContext* StoragePartitionImpl::GetFileSystemContext() {
   return filesystem_context_.get();
 }
 
 webkit_database::DatabaseTracker* StoragePartitionImpl::GetDatabaseTracker() {
   return database_tracker_.get();
 }
 
-DOMStorageContextImpl* StoragePartitionImpl::GetDOMStorageContext() {
+DOMStorageContextWrapper* StoragePartitionImpl::GetDOMStorageContext() {
   return dom_storage_context_.get();
 }
 
 IndexedDBContextImpl* StoragePartitionImpl::GetIndexedDBContext() {
   return indexed_db_context_.get();
 }
 
 void StoragePartitionImpl::ClearDataImpl(
     uint32 remove_mask,
     uint32 quota_storage_remove_mask,
@@ skipping 114 matching lines @@
     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,
-    DOMStorageContextImpl* dom_storage_context,
+    DOMStorageContextWrapper* dom_storage_context,
     quota::QuotaManager* quota_manager,
     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));
 
@@ skipping 84 matching lines @@
     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