Move sqlite_channel_id_store from chrome/browser/net to net/extras.

net/sqlite/sqlite_server_bound_cert_store.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 "chrome/browser/net/sqlite_server_bound_cert_store.h"
+#include "net/sqlite/sqlite_server_bound_cert_store.h"
 
 #include <list>
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "net/cert/x509_certificate.h"
 #include "net/cookies/cookie_util.h"
+#include "net/sqlite/special_storage_policy_delegate.h"
 #include "net/ssl/ssl_client_cert_type.h"
 #include "sql/error_delegate_util.h"
 #include "sql/meta_table.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
-#include "third_party/sqlite/sqlite3.h"
 #include "url/gurl.h"
-#include "webkit/browser/quota/special_storage_policy.h"
+
+namespace net {
 
 // 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 SQLiteServerBoundCertStore::Backend
     : public base::RefCountedThreadSafe<SQLiteServerBoundCertStore::Backend> {
  public:
   Backend(
       const base::FilePath& path,
       const scoped_refptr<base::SequencedTaskRunner>& background_task_runner,
-      quota::SpecialStoragePolicy* special_storage_policy)
+      SpecialStoragePolicyDelegate* 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 certificates stored for.
   std::set<std::string> cert_origins_;
 
   scoped_refptr<base::SequencedTaskRunner> background_task_runner_;
 
-  scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy_;
+  scoped_refptr<SpecialStoragePolicyDelegate> 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 457 matching lines @@
 }
 
 void SQLiteServerBoundCertStore::Backend::SetForceKeepSessionState() {
   base::AutoLock locked(lock_);
   force_keep_session_state_ = true;
 }
 
 SQLiteServerBoundCertStore::SQLiteServerBoundCertStore(
     const base::FilePath& path,
     const scoped_refptr<base::SequencedTaskRunner>& background_task_runner,
-    quota::SpecialStoragePolicy* special_storage_policy)
+    SpecialStoragePolicyDelegate* special_storage_policy)
     : backend_(new Backend(path,
                            background_task_runner,
                            special_storage_policy)) {}
 
 void SQLiteServerBoundCertStore::Load(
     const LoadedCallback& loaded_callback) {
   backend_->Load(loaded_callback);
 }
 
 void SQLiteServerBoundCertStore::AddServerBoundCert(
     const net::DefaultServerBoundCertStore::ServerBoundCert& cert) {
   backend_->AddServerBoundCert(cert);
 }
 
 void SQLiteServerBoundCertStore::DeleteServerBoundCert(
     const net::DefaultServerBoundCertStore::ServerBoundCert& cert) {
   backend_->DeleteServerBoundCert(cert);
 }
 
 void SQLiteServerBoundCertStore::SetForceKeepSessionState() {
   backend_->SetForceKeepSessionState();
 }
 
 SQLiteServerBoundCertStore::~SQLiteServerBoundCertStore() {
   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.
 }
+
+}  // namespace net