Blob support for IDB [Chromium]

content/browser/indexed_db/indexed_db_factory.cc

 // Copyright (c) 2013 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_factory.h"
 
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "content/browser/indexed_db/indexed_db_backing_store.h"
@@ skipping 23 matching lines @@
 
   // No grace period on a forced-close, as the initiator is
   // assuming the backing store will be released once all
   // connections are closed.
   ReleaseBackingStore(origin_url, forcedClose);
 }
 
 void IndexedDBFactory::ReleaseBackingStore(const GURL& origin_url,
                                            bool immediate) {
   // Only close if this is the last reference.
-  if (!HasLastBackingStoreReference(origin_url))
+  if (!HasLastBackingStoreReference(origin_url, immediate))
     return;
 
   // If this factory does hold the last reference to the backing store, it can
   // be closed - but unless requested to close it immediately, keep it around
   // for a short period so that a re-open is fast.
   if (immediate) {
     CloseBackingStore(origin_url);
     return;
   }
 
   // Start a timer to close the backing store, unless something else opens it
   // in the mean time.
   DCHECK(!backing_store_map_[origin_url]->close_timer()->IsRunning());
   backing_store_map_[origin_url]->close_timer()->Start(
       FROM_HERE,
       base::TimeDelta::FromMilliseconds(kBackingStoreGracePeriodMs),
       base::Bind(&IndexedDBFactory::MaybeCloseBackingStore, this, origin_url));
 }
 
 void IndexedDBFactory::MaybeCloseBackingStore(const GURL& origin_url) {
   // Another reference may have opened since the maybe-close was posted, so it
   // is necessary to check again.
-  if (HasLastBackingStoreReference(origin_url))
+  if (HasLastBackingStoreReference(origin_url, false))
     CloseBackingStore(origin_url);
 }
 
 void IndexedDBFactory::CloseBackingStore(const GURL& origin_url) {
   IndexedDBBackingStoreMap::iterator it = backing_store_map_.find(origin_url);
   DCHECK(it != backing_store_map_.end());
   // Stop the timer (if it's running) - this may happen if the timer was started
   // and then a forced close occurs.
   it->second->close_timer()->Stop();
   backing_store_map_.erase(it);
 }
 
-bool IndexedDBFactory::HasLastBackingStoreReference(const GURL& origin_url)
-    const {
+bool IndexedDBFactory::HasLastBackingStoreReference(const GURL& origin_url,
+    bool forcedClose) const {
   IndexedDBBackingStore* ptr;
   {
     // Scope so that the implicit scoped_refptr<> is freed.
     IndexedDBBackingStoreMap::const_iterator it =
         backing_store_map_.find(origin_url);
     DCHECK(it != backing_store_map_.end());
     ptr = it->second.get();
   }
+  if (ptr->HasOneRef())
+    return true;
+  if (!forcedClose)
+    return false;
+  ptr->active_blob_registry()->ForceShutdown();

[jsbell, 2013/12/03 00:10:03]

Hrm, unfortunate placement (in a Has.... method). 

If ForceShutdown() is idempotent, it looks like this would be equivalent to
putting this at the top of ReleaseBackingStore(), e.g. if (immediate) {
...->ForceShutdown(); } 

... which seems fragile, as we'd do a ForceShutdown even if this was not the
last-except-for-registry ref. And if ForceShutdown() is not idempontent then
this is problematic if e.g. there are multiple connections databases being force
closed, since ForceShutdown() will be called multiple times.

[jsbell, 2013/12/03 00:11:24]

ISTM this is a good reason to move away from relying on refcounting for this,
and move to a separate means of use tracking. (It was a toss-up at the time.)

[ericu, 2013/12/03 02:03:55]

It's idempotent, but currently assumes that once it's called, nobody does any
more Gets that pull out blobs.  If that's not a valid assumption, it's easy to
fix.  Pulling ForceShutdown up to the top of ReleaseBackingStore as you suggest
should work.  I'd pull out that infinite loop where the two functions call each
other until the last reference goes away, too ;'>.

[ericu, 2013/12/03 02:03:55]

I'm fine with that too; this code I've put in feels a bit more complex than I'd
like.  I'd worry that it might get broken by later changes.  Do you have plans
for what would replace this?

   return ptr->HasOneRef();
 }
 
 void IndexedDBFactory::ContextDestroyed() {
   // Timers on backing stores hold a reference to this factory. When the
   // context (which nominally owns this factory) is destroyed during thread
   // termination the timers must be stopped so that this factory and the
   // stores can be disposed of.
   for (IndexedDBBackingStoreMap::iterator it = backing_store_map_.begin();
        it != backing_store_map_.end();
        ++it)
     it->second->close_timer()->Stop();
   backing_store_map_.clear();
   context_ = NULL;
 }
 
 void IndexedDBFactory::GetDatabaseNames(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     const GURL& origin_url,
-    const base::FilePath& data_directory) {
+    const base::FilePath& data_directory,
+    base::TaskRunner* task_runner) {
   IDB_TRACE("IndexedDBFactory::GetDatabaseNames");
   // TODO(dgrogan): Plumb data_loss back to script eventually?
   blink::WebIDBDataLoss data_loss;
   std::string data_loss_message;
   bool disk_full;
   scoped_refptr<IndexedDBBackingStore> backing_store =
       OpenBackingStore(origin_url,
                        data_directory,
+                       NULL,
                        &data_loss,
                        &data_loss_message,
-                       &disk_full);
+                       &disk_full,
+                       task_runner);
   if (!backing_store) {
     callbacks->OnError(
         IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
                                "Internal error opening backing store for "
                                "indexedDB.webkitGetDatabaseNames."));
     return;
   }
 
   callbacks->OnSuccess(backing_store->GetDatabaseNames());
 }
 
 void IndexedDBFactory::DeleteDatabase(
     const string16& name,
+    net::URLRequestContext* request_context,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     const GURL& origin_url,
-    const base::FilePath& data_directory) {
+    const base::FilePath& data_directory,
+    base::TaskRunner* task_runner) {
   IDB_TRACE("IndexedDBFactory::DeleteDatabase");
   IndexedDBDatabase::Identifier unique_identifier(origin_url, name);
   IndexedDBDatabaseMap::iterator it = database_map_.find(unique_identifier);
   if (it != database_map_.end()) {
     // If there are any connections to the database, directly delete the
     // database.
     it->second->DeleteDatabase(callbacks);
     return;
   }
 
   // TODO(dgrogan): Plumb data_loss back to script eventually?
   blink::WebIDBDataLoss data_loss;
   std::string data_loss_message;
   bool disk_full = false;
   scoped_refptr<IndexedDBBackingStore> backing_store =
       OpenBackingStore(origin_url,
                        data_directory,
+                       request_context,
                        &data_loss,
                        &data_loss_message,
-                       &disk_full);
+                       &disk_full,
+                       task_runner);
   if (!backing_store) {
     callbacks->OnError(
         IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
                                ASCIIToUTF16(
                                    "Internal error opening backing store "
                                    "for indexedDB.deleteDatabase.")));
     return;
   }
 
   scoped_refptr<IndexedDBDatabase> database =
@@ skipping 20 matching lines @@
 }
 
 bool IndexedDBFactory::IsBackingStoreOpenForTesting(const GURL& origin_url)
     const {
   return backing_store_map_.find(origin_url) != backing_store_map_.end();
 }
 
 scoped_refptr<IndexedDBBackingStore> IndexedDBFactory::OpenBackingStore(
     const GURL& origin_url,
     const base::FilePath& data_directory,
+    net::URLRequestContext* request_context,
     blink::WebIDBDataLoss* data_loss,
     std::string* data_loss_message,
-    bool* disk_full) {
+    bool* disk_full,
+    base::TaskRunner* task_runner) {
   const bool open_in_memory = data_directory.empty();
 
   IndexedDBBackingStoreMap::iterator it2 = backing_store_map_.find(origin_url);
   if (it2 != backing_store_map_.end()) {
     it2->second->close_timer()->Stop();
     return it2->second;
   }
 
   scoped_refptr<IndexedDBBackingStore> backing_store;
+  bool first_time = false;
   if (open_in_memory) {
+    // TODO(ericu): Support blobs in in-memory backends.
     backing_store = IndexedDBBackingStore::OpenInMemory(origin_url);
   } else {
-    backing_store = IndexedDBBackingStore::Open(origin_url,
+    first_time = !backends_opened_since_boot_.count(origin_url);
+    backing_store = IndexedDBBackingStore::Open(this,
+                                                origin_url,
                                                 data_directory,
+                                                request_context,
                                                 data_loss,
                                                 data_loss_message,
-                                                disk_full);
+                                                disk_full,
+                                                task_runner,
+                                                first_time);
   }
 
   if (backing_store.get()) {
+    if (first_time)
+      backends_opened_since_boot_.insert(origin_url);
     backing_store_map_[origin_url] = backing_store;
     // If an in-memory database, bind lifetime to this factory instance.
     if (open_in_memory)
       session_only_backing_stores_.insert(backing_store);
 
     // All backing stores associated with this factory should be of the same
     // type.
-    DCHECK(session_only_backing_stores_.empty() || open_in_memory);
+    DCHECK(session_only_backing_stores_.empty() != open_in_memory);
 
     return backing_store;
   }
 
   return 0;
 }
 
 void IndexedDBFactory::Open(
     const string16& name,
     int64 version,
+    net::URLRequestContext* request_context,
     int64 transaction_id,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
     const GURL& origin_url,
-    const base::FilePath& data_directory) {
+    const base::FilePath& data_directory,
+    int child_process_id,
+    base::TaskRunner* task_runner) {
   IDB_TRACE("IndexedDBFactory::Open");
   scoped_refptr<IndexedDBDatabase> database;
   IndexedDBDatabase::Identifier unique_identifier(origin_url, name);
   IndexedDBDatabaseMap::iterator it = database_map_.find(unique_identifier);
   blink::WebIDBDataLoss data_loss =
       blink::WebIDBDataLossNone;
   std::string data_loss_message;
   bool disk_full = false;
   if (it == database_map_.end()) {
     scoped_refptr<IndexedDBBackingStore> backing_store =
         OpenBackingStore(origin_url,
                          data_directory,
+                         request_context,
                          &data_loss,
                          &data_loss_message,
-                         &disk_full);
+                         &disk_full,
+                         task_runner);
     if (!backing_store) {
       if (disk_full) {
         callbacks->OnError(
             IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionQuotaError,
                                    ASCIIToUTF16(
                                        "Encountered full disk while opening "
                                        "backing store for indexedDB.open.")));
         return;
       }
       callbacks->OnError(IndexedDBDatabaseError(
@@ skipping 13 matching lines @@
       return;
     }
 
     database_map_[unique_identifier] = database;
   } else {
     database = it->second;
   }
 
   database->OpenConnection(callbacks,
                            database_callbacks,
+                           child_process_id,
                            transaction_id,
                            version,
                            data_loss,
                            data_loss_message);
 }
 
 std::vector<IndexedDBDatabase*> IndexedDBFactory::GetOpenDatabasesForOrigin(
     const GURL& origin_url) const {
   std::vector<IndexedDBDatabase*> result;
   for (IndexedDBDatabaseMap::const_iterator it = database_map_.begin();
        it != database_map_.end();
        ++it) {
     if (it->first.first == origin_url)
       result.push_back(it->second.get());
   }
   return result;
 }
 
 }  // namespace content