IndexedDBFactory now ForceCloses databases.

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"
 #include "content/browser/indexed_db/indexed_db_context_impl.h"
 #include "content/browser/indexed_db/indexed_db_tracing.h"
 #include "content/browser/indexed_db/indexed_db_transaction_coordinator.h"
 #include "third_party/WebKit/public/platform/WebIDBDatabaseException.h"
 #include "webkit/common/database/database_identifier.h"
 
 using base::ASCIIToUTF16;
 
 namespace content {
 
 const int64 kBackingStoreGracePeriodMs = 2000;
 
 IndexedDBFactory::IndexedDBFactory(IndexedDBContextImpl* context)
     : context_(context) {}
 
 IndexedDBFactory::~IndexedDBFactory() {}
 
+void IndexedDBFactory::RemoveDatabaseFromMaps(
+    const IndexedDBDatabase::Identifier& identifier) {
+  IndexedDBDatabaseMap::iterator it = database_map_.find(identifier);
+  DCHECK(it != database_map_.end());
+  IndexedDBDatabase* database = it->second;
+  database_map_.erase(it);
+
+  std::pair<OriginDbMapIterator, OriginDbMapIterator> range =
+      GetOpenDatabasesForOrigin(database->identifier().first);
+  DCHECK(range.first != range.second);
+  for (OriginDbMapIterator it2 = range.first; it2 != range.second; ++it2) {
+    if (it2->second == database) {
+      origin_dbs_.erase(it2);
+      break;
+    }
+  }
+}
+
 void IndexedDBFactory::ReleaseDatabase(
     const IndexedDBDatabase::Identifier& identifier,
     bool forcedClose) {
-  IndexedDBDatabaseMap::iterator it = database_map_.find(identifier);
-  DCHECK(it != database_map_.end());
-  DCHECK(!it->second->backing_store());
-  database_map_.erase(it);
+
+  DCHECK(!database_map_.find(identifier)->second->backing_store());
+
+  RemoveDatabaseFromMaps(identifier);
 
   // No grace period on a forced-close, as the initiator is
   // assuming the backing store will be released once all
   // connections are closed.
   ReleaseBackingStore(identifier.first, forcedClose);
 }
 
 void IndexedDBFactory::ReleaseBackingStore(const GURL& origin_url,
                                            bool immediate) {
   // Only close if this is the last reference.
@@ skipping 40 matching lines @@
     // 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();
   }
   return ptr->HasOneRef();
 }
 
 void IndexedDBFactory::ForceClose(const GURL& origin_url) {
+  std::pair<OriginDbMapIterator, OriginDbMapIterator> range =
+      GetOpenDatabasesForOrigin(origin_url);
+
+  // Iterate this way because ForceClose will call back into this instance

[jsbell, 2014/01/03 00:34:25]

Would the standard "advance iterator before erasing" pattern work here?

while (range.first != range.second) {
  IndexedDBDatabase* db = range.first->second;
  ++range.first;
  db->ForceClose();
}

[cmumford, 2014/01/03 21:34:01]

I wasn't confident enough with the multimap iterator to know if that was a safe
thing to do. Your suggestion does work however, and all tests pass.

+  // to remove the database from this map - thus invaliding an iterator.
+  while (range.first != range.second) {
+    range.first->second->ForceClose();  // Force close the database
+    range = GetOpenDatabasesForOrigin(origin_url);
+  }
+
   if (backing_store_map_.find(origin_url) != backing_store_map_.end())
     ReleaseBackingStore(origin_url, true /* immediate */);
 }
 
 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();
@@ skipping 71 matching lines @@
   if (!database) {
     callbacks->OnError(IndexedDBDatabaseError(
         blink::WebIDBDatabaseExceptionUnknownError,
         ASCIIToUTF16(
             "Internal error creating database backend for "
             "indexedDB.deleteDatabase.")));
     return;
   }
 
   database_map_[unique_identifier] = database;
+  origin_dbs_.insert(std::make_pair(origin_url, database));
   database->DeleteDatabase(callbacks);
-  database_map_.erase(unique_identifier);
+  RemoveDatabaseFromMaps(unique_identifier);
   database = NULL;
   backing_store = NULL;
   ReleaseBackingStore(origin_url, false /* immediate */);
 }
 
 void IndexedDBFactory::DatabaseDeleted(
     const IndexedDBDatabase::Identifier& identifier) {
   // NULL after ContextDestroyed() called, and in some unit tests.
   if (!context_)
     return;
@@ skipping 119 matching lines @@
   } else {
     database = it->second;
   }
 
   if (data_loss != blink::WebIDBDataLossNone)
     callbacks->OnDataLoss(data_loss, data_loss_message);
 
   database->OpenConnection(
       callbacks, database_callbacks, transaction_id, version);
 
-  if (!was_open && database->ConnectionCount() > 0)
+  if (!was_open && database->ConnectionCount() > 0) {
     database_map_[unique_identifier] = database;
+    origin_dbs_.insert(std::make_pair(origin_url, database));
+  }
 }
 
-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);
-  }
-  return result;
+std::pair<IndexedDBFactory::OriginDbMapIterator,
+          IndexedDBFactory::OriginDbMapIterator>
+IndexedDBFactory::GetOpenDatabasesForOrigin(const GURL& origin_url) const {
+  return origin_dbs_.equal_range(origin_url);
+}
+
+size_t IndexedDBFactory::GetConnectionCount(const GURL& origin_url) const {
+  size_t count(0);
+
+  std::pair<OriginDbMapIterator, OriginDbMapIterator> range =

[jsbell, 2014/01/03 00:34:25]

Can't this be:

return origin_dbs_.count(origin_url) ?

[cmumford, 2014/01/03 21:34:01]

That would return the number of open DB's for an origin, but not the number of
connections right?

[jsbell, 2014/01/03 21:37:26]

Oops, you're right, sorry.

+      GetOpenDatabasesForOrigin(origin_url);
+  for (OriginDbMapIterator it = range.first; it != range.second; ++it)
+    count += it->second->ConnectionCount();
+
+  return count;
 }
 
 }  // namespace content