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

chrome/browser/net/sqlite_channel_id_store.cc

 // Copyright 2014 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/sqlite_channel_id_store.h"
 
 #include <list>
 #include <set>
 
 #include "base/basictypes.h"
@@ skipping 18 matching lines @@
 #include "webkit/browser/quota/special_storage_policy.h"
 
 // This class is designed to be shared between any calling threads and the
 // background task runner. It batches operations and commits them on a timer.
 class SQLiteChannelIDStore::Backend
     : public base::RefCountedThreadSafe<SQLiteChannelIDStore::Backend> {
  public:
   Backend(
       const base::FilePath& path,
       const scoped_refptr<base::SequencedTaskRunner>& background_task_runner,
-      quota::SpecialStoragePolicy* special_storage_policy)
+      storage::SpecialStoragePolicy* special_storage_policy)
       : path_(path),
         num_pending_(0),
         force_keep_session_state_(false),
         background_task_runner_(background_task_runner),
         special_storage_policy_(special_storage_policy),
         corruption_detected_(false) {}
 
   // Creates or loads the SQLite database.
   void Load(const LoadedCallback& loaded_callback);
 
@@ skipping 73 matching lines @@
   // True if the persistent store should skip clear on exit rules.
   bool force_keep_session_state_;
   // Guard |pending_|, |num_pending_| and |force_keep_session_state_|.
   base::Lock lock_;
 
   // Cache of origins we have channel IDs stored for.
   std::set<std::string> channel_id_origins_;
 
   scoped_refptr<base::SequencedTaskRunner> background_task_runner_;
 
-  scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy_;
+  scoped_refptr<storage::SpecialStoragePolicy> special_storage_policy_;
 
   // Indicates if the kill-database callback has been scheduled.
   bool corruption_detected_;
 
   DISALLOW_COPY_AND_ASSIGN(Backend);
 };
 
 // Version number of the database.
 static const int kCurrentVersionNumber = 4;
 static const int kCompatibleVersionNumber = 1;
@@ skipping 459 matching lines @@
 }
 
 void SQLiteChannelIDStore::Backend::SetForceKeepSessionState() {
   base::AutoLock locked(lock_);
   force_keep_session_state_ = true;
 }
 
 SQLiteChannelIDStore::SQLiteChannelIDStore(
     const base::FilePath& path,
     const scoped_refptr<base::SequencedTaskRunner>& background_task_runner,
-    quota::SpecialStoragePolicy* special_storage_policy)
-    : backend_(new Backend(path,
-                           background_task_runner,
-                           special_storage_policy)) {}
+    storage::SpecialStoragePolicy* special_storage_policy)
+    : backend_(
+          new Backend(path, background_task_runner, special_storage_policy)) {
+}
 
 void SQLiteChannelIDStore::Load(
     const LoadedCallback& loaded_callback) {
   backend_->Load(loaded_callback);
 }
 
 void SQLiteChannelIDStore::AddChannelID(
     const net::DefaultChannelIDStore::ChannelID& channel_id) {
   backend_->AddChannelID(channel_id);
 }
 
 void SQLiteChannelIDStore::DeleteChannelID(
     const net::DefaultChannelIDStore::ChannelID& channel_id) {
   backend_->DeleteChannelID(channel_id);
 }
 
 void SQLiteChannelIDStore::SetForceKeepSessionState() {
   backend_->SetForceKeepSessionState();
 }
 
 SQLiteChannelIDStore::~SQLiteChannelIDStore() {
   backend_->Close();
   // We release our reference to the Backend, though it will probably still have
   // a reference if the background thread has not run Close() yet.
 }