mandoline filesystem: Save cookie data to the mojo:filesystem.

net/extras/sqlite/sqlite_persistent_cookie_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 "net/extras/sqlite/sqlite_persistent_cookie_store.h"
 
 #include <map>
 #include <set>
 
 #include "base/basictypes.h"
@@ skipping 111 matching lines @@
   void UpdateCookieAccessTime(const CanonicalCookie& cc);
 
   // Batch a cookie deletion.
   void DeleteCookie(const CanonicalCookie& cc);
 
   // Commit pending operations as soon as possible.
   void Flush(const base::Closure& callback);
 
   // Commit any pending operations and close the database.  This must be called
   // before the object is destructed.
-  void Close();
+  void Close(const base::Closure& callback);
 
   // Post background delete of all cookies that match |cookies|.
   void DeleteAllInList(const std::list<CookieOrigin>& cookies);
 
  private:
   friend class base::RefCountedThreadSafe<SQLitePersistentCookieStore::Backend>;
 
   // You should call Close() before destructing this object.
   ~Backend() {
     DCHECK(!db_.get()) << "Close should have already been called.";
@@ skipping 72 matching lines @@
 
   // Load all cookies for a set of domains/hosts
   bool LoadCookiesForDomains(const std::set<std::string>& key);
 
   // Batch a cookie operation (add or delete)
   void BatchOperation(PendingOperation::OperationType op,
                       const CanonicalCookie& cc);
   // Commit our pending operations to the database.
   void Commit();
   // Close() executed on the background runner.
-  void InternalBackgroundClose();
+  void InternalBackgroundClose(const base::Closure& callback);
 
   void DeleteSessionCookiesOnStartup();
 
   void DeleteSessionCookiesOnShutdown();
 
   void BackgroundDeleteAllInList(const std::list<CookieOrigin>& cookies);
 
   void DatabaseErrorCallback(int error, sql::Statement* stmt);
   void KillDatabase();
 
@@ skipping 935 matching lines @@
     // We want the completion task to run immediately after Commit() returns.
     // Posting it from here means there is less chance of another task getting
     // onto the message queue first, than if we posted it from Commit() itself.
     PostBackgroundTask(FROM_HERE, callback);
   }
 }
 
 // Fire off a close message to the background runner.  We could still have a
 // pending commit timer or Load operations holding references on us, but if/when
 // this fires we will already have been cleaned up and it will be ignored.
-void SQLitePersistentCookieStore::Backend::Close() {
+void SQLitePersistentCookieStore::Backend::Close(
+    const base::Closure& callback) {
   if (background_task_runner_->RunsTasksOnCurrentThread()) {
-    InternalBackgroundClose();
+    InternalBackgroundClose(callback);
   } else {
     // Must close the backend on the background runner.
-    PostBackgroundTask(FROM_HERE,
-                       base::Bind(&Backend::InternalBackgroundClose, this));
+    PostBackgroundTask(FROM_HERE, base::Bind(&Backend::InternalBackgroundClose,
+                                             this, callback));
   }
 }
 
-void SQLitePersistentCookieStore::Backend::InternalBackgroundClose() {
+void SQLitePersistentCookieStore::Backend::InternalBackgroundClose(
+    const base::Closure& callback) {
   DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
 
   if (delete_session_cookies_at_shutdown_)
     DeleteSessionCookiesOnShutdown();
 
   // Commit any pending operations
   Commit();
 
   meta_table_.Reset();
   db_.reset();
+
+  // We're clean now.
+  if (!callback.is_null())
+    callback.Run();
 }
 
 void SQLitePersistentCookieStore::Backend::DatabaseErrorCallback(
     int error,
     sql::Statement* stmt) {
   DCHECK(background_task_runner_->RunsTasksOnCurrentThread());
 
   if (!sql::IsErrorCatastrophic(error))
     return;
 
@@ skipping 142 matching lines @@
     CookieCryptoDelegate* crypto_delegate)
     : backend_(new Backend(path,
                            client_task_runner,
                            background_task_runner,
                            restore_old_session_cookies,
                            crypto_delegate)) {
 }
 
 void SQLitePersistentCookieStore::DeleteAllInList(
     const std::list<CookieOrigin>& cookies) {
-  backend_->DeleteAllInList(cookies);
+  if (backend_)
+    backend_->DeleteAllInList(cookies);
+}
+
+void SQLitePersistentCookieStore::Close(const base::Closure& callback) {
+  if (backend_) {
+    backend_->Close(callback);
+
+    // We release our reference to the Backend, though it will probably still
+    // have a reference if the background runner has not run
+    // Backend::InternalBackgroundClose() yet.
+    backend_ = nullptr;
+  }
 }
 
 void SQLitePersistentCookieStore::Load(const LoadedCallback& loaded_callback) {
-  backend_->Load(loaded_callback);
+  if (backend_)
+    backend_->Load(loaded_callback);
+  else
+    loaded_callback.Run(std::vector<CanonicalCookie*>());
 }
 
 void SQLitePersistentCookieStore::LoadCookiesForKey(
     const std::string& key,
     const LoadedCallback& loaded_callback) {
-  backend_->LoadCookiesForKey(key, loaded_callback);
+  if (backend_)
+    backend_->LoadCookiesForKey(key, loaded_callback);
+  else
+    loaded_callback.Run(std::vector<CanonicalCookie*>());
 }
 
 void SQLitePersistentCookieStore::AddCookie(const CanonicalCookie& cc) {
-  backend_->AddCookie(cc);
+  if (backend_)
+    backend_->AddCookie(cc);
 }
 
 void SQLitePersistentCookieStore::UpdateCookieAccessTime(
     const CanonicalCookie& cc) {
-  backend_->UpdateCookieAccessTime(cc);
+  if (backend_)
+    backend_->UpdateCookieAccessTime(cc);
 }
 
 void SQLitePersistentCookieStore::DeleteCookie(const CanonicalCookie& cc) {
-  backend_->DeleteCookie(cc);
+  if (backend_)
+    backend_->DeleteCookie(cc);
 }
 
 void SQLitePersistentCookieStore::SetForceKeepSessionState() {
   // This store never discards session-only cookies, so this call has no effect.
 }
 
 void SQLitePersistentCookieStore::Flush(const base::Closure& callback) {
-  backend_->Flush(callback);
+  if (backend_)
+    backend_->Flush(callback);
 }
 
 SQLitePersistentCookieStore::~SQLitePersistentCookieStore() {
-  backend_->Close();
-  // We release our reference to the Backend, though it will probably still have
-  // a reference if the background runner has not run Close() yet.
+  Close(base::Closure());
 }
 
 }  // namespace net