[IndexedDB]: Passing URLRequestContextGetter.

content/browser/indexed_db/indexed_db_factory_impl.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_impl.h"
 
 #include <stdint.h>
 
 #include <utility>
 #include <vector>
@@ skipping 154 matching lines @@
       backing_stores_with_active_blobs_.erase(it);
       ReleaseBackingStore(origin, false /* immediate */);
     }
   }
 }
 
 void IndexedDBFactoryImpl::GetDatabaseNames(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     const Origin& origin,
     const base::FilePath& data_directory,
-    net::URLRequestContext* request_context) {
+    scoped_refptr<net::URLRequestContextGetter> request_context_getter) {
   IDB_TRACE("IndexedDBFactoryImpl::GetDatabaseNames");
   // TODO(dgrogan): Plumb data_loss back to script eventually?
   IndexedDBDataLossInfo data_loss_info;
   bool disk_full;
   leveldb::Status s;
   // TODO(cmumford): Handle this error
-  scoped_refptr<IndexedDBBackingStore> backing_store = OpenBackingStore(
-      origin, data_directory, request_context, &data_loss_info, &disk_full, &s);
+  scoped_refptr<IndexedDBBackingStore> backing_store =
+      OpenBackingStore(origin, data_directory, request_context_getter,
+                       &data_loss_info, &disk_full, &s);
   if (!backing_store.get()) {
     callbacks->OnError(
         IndexedDBDatabaseError(blink::WebIDBDatabaseExceptionUnknownError,
                                "Internal error opening backing store for "
                                "indexedDB.webkitGetDatabaseNames."));
     return;
   }
 
   std::vector<base::string16> names = backing_store->GetDatabaseNames(&s);
   if (!s.ok()) {
     DLOG(ERROR) << "Internal error getting database names";
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  "Internal error opening backing store for "
                                  "indexedDB.webkitGetDatabaseNames.");
     callbacks->OnError(error);
     backing_store = NULL;
     if (s.IsCorruption())
       HandleBackingStoreCorruption(origin, error);
     return;
   }
   callbacks->OnSuccess(names);
   backing_store = NULL;
   ReleaseBackingStore(origin, false /* immediate */);
 }
 
 void IndexedDBFactoryImpl::DeleteDatabase(
     const base::string16& name,
-    net::URLRequestContext* request_context,
+    scoped_refptr<net::URLRequestContextGetter> request_context_getter,
     scoped_refptr<IndexedDBCallbacks> callbacks,
     const Origin& origin,
     const base::FilePath& data_directory) {
   IDB_TRACE("IndexedDBFactoryImpl::DeleteDatabase");
   IndexedDBDatabase::Identifier unique_identifier(origin, name);
   const auto& 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?
   IndexedDBDataLossInfo data_loss_info;
   bool disk_full = false;
   leveldb::Status s;
-  scoped_refptr<IndexedDBBackingStore> backing_store = OpenBackingStore(
-      origin, data_directory, request_context, &data_loss_info, &disk_full, &s);
+  scoped_refptr<IndexedDBBackingStore> backing_store =
+      OpenBackingStore(origin, data_directory, request_context_getter,
+                       &data_loss_info, &disk_full, &s);
   if (!backing_store.get()) {
     IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
                                  ASCIIToUTF16(
                                      "Internal error opening backing store "
                                      "for indexedDB.deleteDatabase."));
     callbacks->OnError(error);
     if (s.IsCorruption()) {
       HandleBackingStoreCorruption(origin, error);
     }
     return;
@@ skipping 93 matching lines @@
   const auto& it = backing_store_map_.find(origin);
   if (it == backing_store_map_.end())
     return false;
   return it->second->close_timer()->IsRunning();
 }
 
 scoped_refptr<IndexedDBBackingStore>
 IndexedDBFactoryImpl::OpenBackingStoreHelper(
     const Origin& origin,
     const base::FilePath& data_directory,
-    net::URLRequestContext* request_context,
+    scoped_refptr<net::URLRequestContextGetter> request_context_getter,
     IndexedDBDataLossInfo* data_loss_info,
     bool* disk_full,
     bool first_time,
     leveldb::Status* status) {
   return IndexedDBBackingStore::Open(
-      this, origin, data_directory, request_context, data_loss_info, disk_full,
-      context_->TaskRunner(), first_time, status);
+      this, origin, data_directory, request_context_getter, data_loss_info,
+      disk_full, context_->TaskRunner(), first_time, status);
 }
 
 scoped_refptr<IndexedDBBackingStore> IndexedDBFactoryImpl::OpenBackingStore(
     const Origin& origin,
     const base::FilePath& data_directory,
-    net::URLRequestContext* request_context,
+    scoped_refptr<net::URLRequestContextGetter> request_context_getter,
     IndexedDBDataLossInfo* data_loss_info,
     bool* disk_full,
     leveldb::Status* status) {
   const bool open_in_memory = data_directory.empty();
 
   const auto& it2 = backing_store_map_.find(origin);
   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, context_->TaskRunner(), status);
   } else {
     first_time = !backends_opened_since_boot_.count(origin);
 
     backing_store =
-        OpenBackingStoreHelper(origin, data_directory, request_context,
+        OpenBackingStoreHelper(origin, data_directory, request_context_getter,
                                data_loss_info, disk_full, first_time, status);
   }
 
   if (backing_store.get()) {
     if (first_time)
       backends_opened_since_boot_.insert(origin);
     backing_store_map_[origin] = 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;
   }
 
   return 0;
 }
 
 void IndexedDBFactoryImpl::Open(
     const base::string16& name,
     std::unique_ptr<IndexedDBPendingConnection> connection,
-    net::URLRequestContext* request_context,
+    scoped_refptr<net::URLRequestContextGetter> request_context_getter,
     const Origin& origin,
     const base::FilePath& data_directory) {
   IDB_TRACE("IndexedDBFactoryImpl::Open");
   scoped_refptr<IndexedDBDatabase> database;
   IndexedDBDatabase::Identifier unique_identifier(origin, name);
   const auto& it = database_map_.find(unique_identifier);
   IndexedDBDataLossInfo data_loss_info;
   bool disk_full = false;
   bool was_open = (it != database_map_.end());
   if (!was_open) {
     leveldb::Status s;
     scoped_refptr<IndexedDBBackingStore> backing_store =
-        OpenBackingStore(origin, data_directory, request_context,
+        OpenBackingStore(origin, data_directory, request_context_getter,
                          &data_loss_info, &disk_full, &s);
     if (!backing_store.get()) {
       if (disk_full) {
         connection->callbacks->OnError(IndexedDBDatabaseError(
             blink::WebIDBDatabaseExceptionQuotaError,
             ASCIIToUTF16("Encountered full disk while opening "
                          "backing store for indexedDB.open.")));
         return;
       }
       IndexedDBDatabaseError error(blink::WebIDBDatabaseExceptionUnknownError,
@@ skipping 47 matching lines @@
   size_t count(0);
 
   OriginDBs range = GetOpenDatabasesForOrigin(origin);
   for (OriginDBMapIterator it = range.first; it != range.second; ++it)
     count += it->second->ConnectionCount();
 
   return count;
 }
 
 }  // namespace content