Abort in-flight load tasks if the DB has been closed.

chrome/browser/net/sqlite_persistent_cookie_store.cc

 // Copyright (c) 2011 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_persistent_cookie_store.h"
 
 #include <list>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 414 matching lines @@
     cookies.swap(cookies_);
   }
 
   loaded_callback.Run(cookies);
 }
 
 bool SQLitePersistentCookieStore::Backend::InitializeDatabase() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
 
   if (initialized_) {
-    return true;
+    // Return false if we were previously initialized but the DB has since been
+    // closed.
+    return db_.get() ? true : false;
   }
 
   const FilePath dir = path_.DirName();
   if (!file_util::PathExists(dir) && !file_util::CreateDirectory(dir)) {
     return false;
   }
 
   db_.reset(new sql::Connection);
   if (!db_->Open(path_)) {
     NOTREACHED() << "Unable to open cookie DB.";
@@ skipping 39 matching lines @@
   return true;
 }
 
 void SQLitePersistentCookieStore::Backend::ChainLoadCookies(
     const LoadedCallback& loaded_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   IncrementTimeDelta increment(&cookie_load_duration_);
 
   bool load_success = true;
 
-  if (keys_to_load_.size() > 0) {
+  if (!db_.get()) {
+    // Close() has been called on this store.
+    load_success = false;
+  } else if (keys_to_load_.size() > 0) {
     // Load cookies for the first domain key.
     std::map<std::string, std::set<std::string> >::iterator
       it = keys_to_load_.begin();
     load_success = LoadCookiesForDomains(it->second);
     keys_to_load_.erase(it);
   }
 
   // If load is successful and there are more domain keys to be loaded,
   // then post a DB task to continue chain-load;
   // Otherwise notify on IO thread.
@@ skipping 309 matching lines @@
       BrowserThread::DB, FROM_HERE, base::Bind(&Backend::Commit, this));
   if (completion_task) {
     // 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.
     BrowserThread::PostTask(BrowserThread::DB, FROM_HERE, completion_task);
   }
 }
 
 // Fire off a close message to the background thread.  We could still have a
-// pending commit timer that will be holding a reference on us, but if/when
+// 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() {
   if (BrowserThread::CurrentlyOn(BrowserThread::DB)) {
     InternalBackgroundClose();
   } else {
     // Must close the backend on the background thread.
     BrowserThread::PostTask(
         BrowserThread::DB, FROM_HERE,
         base::Bind(&Backend::InternalBackgroundClose, this));
   }
@@ skipping 70 matching lines @@
   if (backend_.get())
     backend_->SetClearLocalStateOnExit(clear_local_state);
 }
 
 void SQLitePersistentCookieStore::Flush(Task* completion_task) {
   if (backend_.get())
     backend_->Flush(completion_task);
   else if (completion_task)
     MessageLoop::current()->PostTask(FROM_HERE, completion_task);
 }