Track which IndexedDBBackingStores have been opened since boot.

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 153 matching lines @@
     if (it != backing_stores_with_active_blobs_.end()) {
       backing_stores_with_active_blobs_.erase(it);
       ReleaseBackingStore(origin_url, false /* immediate */);
     }
   }
 }
 
 void IndexedDBFactory::GetDatabaseNames(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     const GURL& origin_url,
-    const base::FilePath& data_directory) {
+    const base::FilePath& data_directory,
+    net::URLRequestContext* request_context) {
   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 /* request_context */,
+                       request_context,
                        &data_loss,
                        &data_loss_message,
                        &disk_full);
   if (!backing_store) {
     callbacks->OnError(
         IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
                                "Internal error opening backing store for "
                                "indexedDB.webkitGetDatabaseNames."));
     return;
   }
@@ skipping 116 matching lines @@
 
 bool IndexedDBFactory::IsBackingStorePendingClose(const GURL& origin_url)
     const {
   IndexedDBBackingStoreMap::const_iterator it =
       backing_store_map_.find(origin_url);
   if (it == backing_store_map_.end())
     return false;
   return it->second->close_timer()->IsRunning();
 }
 
+scoped_refptr<IndexedDBBackingStore> IndexedDBFactory::OpenBackingStoreHelper(

[cmumford, 2014/04/29 16:08:34]

I'm missing the point of this function.

[ericu, 2014/04/29 18:24:19]

Ah, sorry--there's no actual point in this CL.  It's needed a couple of CLs from
now to enable mocking out part of the backend for testing.  I should have
mentioned that in the CL description.

I'm putting it in this CL because 1) I can split it off from a later, larger CL;
2) I'm mucking with the parameters to all these constructors, and that makes
merging messy while I've got multiple CLs in flight at the same time.  If you
prefer, I can push this change back to the CL that needs it, but I think that's
going to be the really big one at the end.

+    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 first_time) {
+  return IndexedDBBackingStore::Open(this,
+                                     origin_url,
+                                     data_directory,
+                                     request_context,
+                                     data_loss,
+                                     data_loss_message,
+                                     disk_full,
+                                     context_->TaskRunner(),
+                                     first_time);
+}
+
 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) {
   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) {
     backing_store =
         IndexedDBBackingStore::OpenInMemory(origin_url, context_->TaskRunner());
   } else {
-    backing_store = IndexedDBBackingStore::Open(this,
-                                                origin_url,
-                                                data_directory,
-                                                data_loss,
-                                                data_loss_message,
-                                                disk_full,
-                                                context_->TaskRunner());
+    first_time = !backends_opened_since_boot_.count(origin_url);
+
+    backing_store = OpenBackingStoreHelper(origin_url,
+                                           data_directory,
+                                           request_context,
+                                           data_loss,
+                                           data_loss_message,
+                                           disk_full,
+                                           first_time);
   }
 
   if (backing_store.get()) {
+    if (first_time)
+      backends_opened_since_boot_.insert(origin_url);

[cmumford, 2014/04/29 16:08:34]

If this is already a set why calculate/pass the first_time param? Why not just
let the set (backends_opened_since_boot_) do that by it's intrinsic nature?

[ericu, 2014/04/29 18:24:19]

I don't understand the question.  Do you mean why not just always call insert,
or why use a temporary variable instead of just passing
!backends_opened_since_boot_.count(origin_url)?  The former's a tiny
optimization [possibly unnecessary] and I think the latter makes the code a
little more readable.

     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_NE(session_only_backing_stores_.empty(), open_in_memory);
 
     return backing_store;
@@ skipping 83 matching lines @@
 
   std::pair<OriginDBMapIterator, OriginDBMapIterator> range =
       GetOpenDatabasesForOrigin(origin_url);
   for (OriginDBMapIterator it = range.first; it != range.second; ++it)
     count += it->second->ConnectionCount();
 
   return count;
 }
 
 }  // namespace content