Added IndexedDBPendingConnection to group up a bunch of parameters that get

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 276 matching lines @@
     // All backing stores associated with this factory should be of the same
     // type.
     DCHECK(session_only_backing_stores_.empty() || open_in_memory);
 
     return backing_store;
   }
 
   return 0;
 }
 
-void IndexedDBFactory::Open(
-    const base::string16& name,
-    int64 version,
-    int64 transaction_id,
-    scoped_refptr<IndexedDBCallbacks> callbacks,
-    scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
-    const GURL& origin_url,
-    const base::FilePath& data_directory) {
+void IndexedDBFactory::Open(const base::string16& name,
+                            const IndexedDBPendingConnection& connection,
+                            const GURL& origin_url,
+                            const base::FilePath& data_directory) {
   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;
   bool was_open = (it != database_map_.end());
   if (!was_open) {
     scoped_refptr<IndexedDBBackingStore> backing_store =
         OpenBackingStore(origin_url,
                          data_directory,
                          &data_loss,
                          &data_loss_message,
                          &disk_full);
     if (!backing_store) {
       if (disk_full) {
-        callbacks->OnError(
+        connection.callbacks->OnError(
             IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionQuotaError,
                                    ASCIIToUTF16(
                                        "Encountered full disk while opening "
                                        "backing store for indexedDB.open.")));
         return;
       }
-      callbacks->OnError(IndexedDBDatabaseError(
+      connection.callbacks->OnError(IndexedDBDatabaseError(
           blink::WebIDBDatabaseExceptionUnknownError,
           ASCIIToUTF16(
               "Internal error opening backing store for indexedDB.open.")));
       return;
     }
 
     database =
         IndexedDBDatabase::Create(name, backing_store, this, unique_identifier);
     if (!database) {
-      callbacks->OnError(IndexedDBDatabaseError(
+      connection.callbacks->OnError(IndexedDBDatabaseError(
           blink::WebIDBDatabaseExceptionUnknownError,
           ASCIIToUTF16(
               "Internal error creating database backend for indexedDB.open.")));
       return;
     }
   } else {
     database = it->second;
   }
 
   if (data_loss != blink::WebIDBDataLossNone)
-    callbacks->OnDataLoss(data_loss, data_loss_message);
+    connection.callbacks->OnDataLoss(data_loss, data_loss_message);
 
-  database->OpenConnection(
-      callbacks, database_callbacks, transaction_id, version);
+  database->OpenConnection(connection);
 
   if (!was_open && database->ConnectionCount() > 0) {
     database_map_[unique_identifier] = database;
     origin_dbs_.insert(std::make_pair(origin_url, database));
   }
 }
 
 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 =
       GetOpenDatabasesForOrigin(origin_url);
   for (OriginDBMapIterator it = range.first; it != range.second; ++it)
     count += it->second->ConnectionCount();
 
   return count;
 }
 
 }  // namespace content