Collapse fileapi, webkit_blob, webkit_database, quota, and webkit_common namespaces into single sto…

content/browser/indexed_db/indexed_db_context_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/indexed_db/indexed_db_context_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 20 matching lines @@
 #include "content/public/browser/indexed_db_info.h"
 #include "content/public/common/content_switches.h"
 #include "ui/base/text/bytes_formatting.h"
 #include "webkit/browser/database/database_util.h"
 #include "webkit/browser/quota/quota_manager_proxy.h"
 #include "webkit/browser/quota/special_storage_policy.h"
 #include "webkit/common/database/database_identifier.h"
 
 using base::DictionaryValue;
 using base::ListValue;
-using webkit_database::DatabaseUtil;
+using storage::DatabaseUtil;
 
 namespace content {
 const base::FilePath::CharType IndexedDBContextImpl::kIndexedDBDirectory[] =
     FILE_PATH_LITERAL("IndexedDB");
 
 static const base::FilePath::CharType kIndexedDBExtension[] =
     FILE_PATH_LITERAL(".indexeddb");
 
 static const base::FilePath::CharType kLevelDBExtension[] =
     FILE_PATH_LITERAL(".leveldb");
 
 namespace {
 
 // This may be called after the IndexedDBContext is destroyed.
 void GetAllOriginsAndPaths(const base::FilePath& indexeddb_path,
                            std::vector<GURL>* origins,
                            std::vector<base::FilePath>* file_paths) {
   // TODO(jsbell): DCHECK that this is running on an IndexedDB thread,
   // if a global handle to it is ever available.
   if (indexeddb_path.empty())
     return;
   base::FileEnumerator file_enumerator(
       indexeddb_path, false, base::FileEnumerator::DIRECTORIES);
   for (base::FilePath file_path = file_enumerator.Next(); !file_path.empty();
        file_path = file_enumerator.Next()) {
     if (file_path.Extension() == kLevelDBExtension &&
         file_path.RemoveExtension().Extension() == kIndexedDBExtension) {
       std::string origin_id = file_path.BaseName().RemoveExtension()
           .RemoveExtension().MaybeAsASCII();
-      origins->push_back(webkit_database::GetOriginFromIdentifier(origin_id));
+      origins->push_back(storage::GetOriginFromIdentifier(origin_id));
       if (file_paths)
         file_paths->push_back(file_path);
     }
   }
 }
 
 // This will be called after the IndexedDBContext is destroyed.
 void ClearSessionOnlyOrigins(
     const base::FilePath& indexeddb_path,
-    scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy) {
+    scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy) {
   // TODO(jsbell): DCHECK that this is running on an IndexedDB thread,
   // if a global handle to it is ever available.
   std::vector<GURL> origins;
   std::vector<base::FilePath> file_paths;
   GetAllOriginsAndPaths(indexeddb_path, &origins, &file_paths);
   DCHECK_EQ(origins.size(), file_paths.size());
   std::vector<base::FilePath>::const_iterator file_path_iter =
       file_paths.begin();
   for (std::vector<GURL>::const_iterator iter = origins.begin();
        iter != origins.end();
        ++iter, ++file_path_iter) {
     if (!special_storage_policy->IsStorageSessionOnly(*iter))
       continue;
     if (special_storage_policy->IsStorageProtected(*iter))
       continue;
     base::DeleteFile(*file_path_iter, true);
   }
 }
 
 }  // namespace
 
 IndexedDBContextImpl::IndexedDBContextImpl(
     const base::FilePath& data_path,
-    quota::SpecialStoragePolicy* special_storage_policy,
-    quota::QuotaManagerProxy* quota_manager_proxy,
+    storage::SpecialStoragePolicy* special_storage_policy,
+    storage::QuotaManagerProxy* quota_manager_proxy,
     base::SequencedTaskRunner* task_runner)
     : force_keep_session_state_(false),
       special_storage_policy_(special_storage_policy),
       quota_manager_proxy_(quota_manager_proxy),
       task_runner_(task_runner) {
   IDB_TRACE("init");
   if (!data_path.empty())
     data_path_ = data_path.Append(kIndexedDBDirectory);
   if (quota_manager_proxy) {
     quota_manager_proxy->RegisterClient(new IndexedDBQuotaClient(this));
@@ skipping 239 matching lines @@
   if (data_path_.empty() || !IsInOriginSet(origin_url))
     return 0;
 
   if (!factory_)
     return 0;
 
   return factory_->GetConnectionCount(origin_url);
 }
 
 base::FilePath IndexedDBContextImpl::GetFilePath(const GURL& origin_url) const {
-  std::string origin_id = webkit_database::GetIdentifierFromOrigin(origin_url);
+  std::string origin_id = storage::GetIdentifierFromOrigin(origin_url);
   return GetIndexedDBFilePath(origin_id);
 }
 
 base::FilePath IndexedDBContextImpl::GetFilePathForTesting(
     const std::string& origin_id) const {
   return GetIndexedDBFilePath(origin_id);
 }
 
 void IndexedDBContextImpl::SetTaskRunnerForTesting(
     base::SequencedTaskRunner* task_runner) {
   DCHECK(!task_runner_);
   task_runner_ = task_runner;
 }
 
 void IndexedDBContextImpl::ConnectionOpened(const GURL& origin_url,
                                             IndexedDBConnection* connection) {
   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
   if (quota_manager_proxy()) {
     quota_manager_proxy()->NotifyStorageAccessed(
-        quota::QuotaClient::kIndexedDatabase,
+        storage::QuotaClient::kIndexedDatabase,
         origin_url,
-        quota::kStorageTypeTemporary);
+        storage::kStorageTypeTemporary);
   }
   if (AddToOriginSet(origin_url)) {
     // A newly created db, notify the quota system.
     QueryDiskAndUpdateQuotaUsage(origin_url);
   } else {
     EnsureDiskUsageCacheInitialized(origin_url);
   }
   QueryAvailableQuota(origin_url);
 }
 
 void IndexedDBContextImpl::ConnectionClosed(const GURL& origin_url,
                                             IndexedDBConnection* connection) {
   DCHECK(TaskRunner()->RunsTasksOnCurrentThread());
   if (quota_manager_proxy()) {
     quota_manager_proxy()->NotifyStorageAccessed(
-        quota::QuotaClient::kIndexedDatabase,
+        storage::QuotaClient::kIndexedDatabase,
         origin_url,
-        quota::kStorageTypeTemporary);
+        storage::kStorageTypeTemporary);
   }
   if (factory_ && factory_->GetConnectionCount(origin_url) == 0)
     QueryDiskAndUpdateQuotaUsage(origin_url);
 }
 
 void IndexedDBContextImpl::TransactionComplete(const GURL& origin_url) {
   DCHECK(!factory_ || factory_->GetConnectionCount(origin_url) > 0);
   QueryDiskAndUpdateQuotaUsage(origin_url);
   QueryAvailableQuota(origin_url);
 }
@@ skipping 12 matching lines @@
   }
   bool over_quota = additional_bytes > space_available_map_[origin_url];
   return over_quota;
 }
 
 bool IndexedDBContextImpl::IsOverQuota(const GURL& origin_url) {
   const int kOneAdditionalByte = 1;
   return WouldBeOverQuota(origin_url, kOneAdditionalByte);
 }
 
-quota::QuotaManagerProxy* IndexedDBContextImpl::quota_manager_proxy() {
+storage::QuotaManagerProxy* IndexedDBContextImpl::quota_manager_proxy() {
   return quota_manager_proxy_;
 }
 
 IndexedDBContextImpl::~IndexedDBContextImpl() {
   if (factory_) {
     TaskRunner()->PostTask(
         FROM_HERE, base::Bind(&IndexedDBFactory::ContextDestroyed, factory_));
     factory_ = NULL;
   }
 
@@ skipping 40 matching lines @@
 void IndexedDBContextImpl::QueryDiskAndUpdateQuotaUsage(
     const GURL& origin_url) {
   int64 former_disk_usage = origin_size_map_[origin_url];
   int64 current_disk_usage = ReadUsageFromDisk(origin_url);
   int64 difference = current_disk_usage - former_disk_usage;
   if (difference) {
     origin_size_map_[origin_url] = current_disk_usage;
     // quota_manager_proxy() is NULL in unit tests.
     if (quota_manager_proxy()) {
       quota_manager_proxy()->NotifyStorageModified(
-          quota::QuotaClient::kIndexedDatabase,
+          storage::QuotaClient::kIndexedDatabase,
           origin_url,
-          quota::kStorageTypeTemporary,
+          storage::kStorageTypeTemporary,
           difference);
     }
   }
 }
 
 void IndexedDBContextImpl::GotUsageAndQuota(const GURL& origin_url,
-                                            quota::QuotaStatusCode status,
+                                            storage::QuotaStatusCode status,
                                             int64 usage,
                                             int64 quota) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  DCHECK(status == quota::kQuotaStatusOk || status == quota::kQuotaErrorAbort)
+  DCHECK(status == storage::kQuotaStatusOk ||
+         status == storage::kQuotaErrorAbort)
       << "status was " << status;
-  if (status == quota::kQuotaErrorAbort) {
+  if (status == storage::kQuotaErrorAbort) {
     // We seem to no longer care to wait around for the answer.
     return;
   }
   TaskRunner()->PostTask(FROM_HERE,
                          base::Bind(&IndexedDBContextImpl::GotUpdatedQuota,
                                     this,
                                     origin_url,
                                     usage,
                                     quota));
 }
@@ skipping 15 matching lines @@
           base::Bind(
               &IndexedDBContextImpl::QueryAvailableQuota, this, origin_url));
     }
     return;
   }
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!quota_manager_proxy() || !quota_manager_proxy()->quota_manager())
     return;
   quota_manager_proxy()->quota_manager()->GetUsageAndQuota(
       origin_url,
-      quota::kStorageTypeTemporary,
+      storage::kStorageTypeTemporary,
       base::Bind(&IndexedDBContextImpl::GotUsageAndQuota, this, origin_url));
 }
 
 std::set<GURL>* IndexedDBContextImpl::GetOriginSet() {
   if (!origin_set_) {
     origin_set_.reset(new std::set<GURL>);
     std::vector<GURL> origins;
     GetAllOriginsAndPaths(data_path_, &origins, NULL);
     for (std::vector<GURL>::const_iterator iter = origins.begin();
          iter != origins.end();
          ++iter) {
       origin_set_->insert(*iter);
     }
   }
   return origin_set_.get();
 }
 
 void IndexedDBContextImpl::ResetCaches() {
   origin_set_.reset();
   origin_size_map_.clear();
   space_available_map_.clear();
 }
 
 base::SequencedTaskRunner* IndexedDBContextImpl::TaskRunner() const {
   return task_runner_;
 }
 
 }  // namespace content