[IndexedDB]: Passing URLRequestContextGetter.

content/browser/indexed_db/indexed_db_dispatcher_host.cc

 // Copyright (c) 2012 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_dispatcher_host.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/guid.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/scoped_vector.h"
 #include "base/process/process.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/indexed_db/indexed_db_callbacks.h"
 #include "content/browser/indexed_db/indexed_db_connection.h"
 #include "content/browser/indexed_db/indexed_db_context_impl.h"
 #include "content/browser/indexed_db/indexed_db_cursor.h"
 #include "content/browser/indexed_db/indexed_db_database_callbacks.h"
 #include "content/browser/indexed_db/indexed_db_metadata.h"
 #include "content/browser/indexed_db/indexed_db_observation.h"
-#include "content/browser/indexed_db/indexed_db_observation.h"
 #include "content/browser/indexed_db/indexed_db_observer_changes.h"
 #include "content/browser/indexed_db/indexed_db_pending_connection.h"
 #include "content/browser/indexed_db/indexed_db_value.h"
 #include "content/browser/renderer_host/render_message_filter.h"
 #include "content/common/indexed_db/indexed_db_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 #include "storage/browser/blob/blob_data_builder.h"
@@ skipping 17 matching lines @@
 
 }  // namespace
 
 IndexedDBDispatcherHost::IndexedDBDispatcherHost(
     int ipc_process_id,
     net::URLRequestContextGetter* request_context_getter,
     IndexedDBContextImpl* indexed_db_context,
     ChromeBlobStorageContext* blob_storage_context)
     : BrowserMessageFilter(IndexedDBMsgStart),
       request_context_getter_(request_context_getter),
-      request_context_(NULL),
       indexed_db_context_(indexed_db_context),
       blob_storage_context_(blob_storage_context),
       database_dispatcher_host_(base::MakeUnique<DatabaseDispatcherHost>(this)),
-      cursor_dispatcher_host_(base::MakeUnique<CursorDispatcherHost>(this)),
-      ipc_process_id_(ipc_process_id) {
-  DCHECK(indexed_db_context_.get());
-}
-
-IndexedDBDispatcherHost::IndexedDBDispatcherHost(
-    int ipc_process_id,
-    net::URLRequestContext* request_context,
-    IndexedDBContextImpl* indexed_db_context,
-    ChromeBlobStorageContext* blob_storage_context)
-    : BrowserMessageFilter(IndexedDBMsgStart),
-      request_context_(request_context),
-      indexed_db_context_(indexed_db_context),
-      blob_storage_context_(blob_storage_context),
-      database_dispatcher_host_(base::MakeUnique<DatabaseDispatcherHost>(this)),
       cursor_dispatcher_host_(base::MakeUnique<CursorDispatcherHost>(this)),
       ipc_process_id_(ipc_process_id) {
   DCHECK(indexed_db_context_.get());
 }
 
 IndexedDBDispatcherHost::~IndexedDBDispatcherHost() {}
 
-void IndexedDBDispatcherHost::OnChannelConnected(int32_t peer_pid) {
-  BrowserMessageFilter::OnChannelConnected(peer_pid);
-
-  if (request_context_getter_.get()) {
-    DCHECK(!request_context_);
-    request_context_ = request_context_getter_->GetURLRequestContext();
-    request_context_getter_ = NULL;
-    DCHECK(request_context_);
-  }
-}
-
 void IndexedDBDispatcherHost::OnChannelClosing() {
   bool success = indexed_db_context_->TaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&IndexedDBDispatcherHost::ResetDispatcherHosts, this));
 
   if (!success)
     ResetDispatcherHosts();
 }
 
 void IndexedDBDispatcherHost::OnDestruct() const {
@@ skipping 230 matching lines @@
 
   if (!IsValidOrigin(params.origin)) {
     bad_message::ReceivedBadMessage(this, bad_message::IDBDH_INVALID_ORIGIN);
     return;
   }
 
   base::FilePath indexed_db_path = indexed_db_context_->data_path();
   context()->GetIDBFactory()->GetDatabaseNames(
       new IndexedDBCallbacks(this, params.ipc_thread_id,
                              params.ipc_callbacks_id),
-      params.origin, indexed_db_path, request_context_);
+      params.origin, indexed_db_path, request_context_getter_);
 }
 
 void IndexedDBDispatcherHost::OnIDBFactoryOpen(
     const IndexedDBHostMsg_FactoryOpen_Params& params) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
 
   if (!IsValidOrigin(params.origin)) {
     bad_message::ReceivedBadMessage(this, bad_message::IDBDH_INVALID_ORIGIN);
     return;
   }
 
   base::TimeTicks begin_time = base::TimeTicks::Now();
   base::FilePath indexed_db_path = indexed_db_context_->data_path();
 
   int64_t host_transaction_id = HostTransactionId(params.transaction_id);
 
   // TODO(dgrogan): Don't let a non-existing database be opened (and therefore
   // created) if this origin is already over quota.
   scoped_refptr<IndexedDBCallbacks> callbacks = new IndexedDBCallbacks(
       this, params.ipc_thread_id, params.ipc_callbacks_id,
       params.ipc_database_callbacks_id, host_transaction_id, params.origin);
   callbacks->SetConnectionOpenStartTime(begin_time);
   scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks =
       new IndexedDBDatabaseCallbacks(
           this, params.ipc_thread_id, params.ipc_database_callbacks_id);
   std::unique_ptr<IndexedDBPendingConnection> connection =
       base::MakeUnique<IndexedDBPendingConnection>(
           callbacks, database_callbacks, ipc_process_id_, host_transaction_id,
           params.version);
-  DCHECK(request_context_);
+  DCHECK(request_context_getter_);
   context()->GetIDBFactory()->Open(params.name, std::move(connection),
-                                   request_context_, params.origin,
+                                   request_context_getter_, params.origin,
                                    indexed_db_path);
 }
 
 void IndexedDBDispatcherHost::OnIDBFactoryDeleteDatabase(
     const IndexedDBHostMsg_FactoryDeleteDatabase_Params& params) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
 
   if (!IsValidOrigin(params.origin)) {
     bad_message::ReceivedBadMessage(this, bad_message::IDBDH_INVALID_ORIGIN);
     return;
   }
 
   base::FilePath indexed_db_path = indexed_db_context_->data_path();
-  DCHECK(request_context_);
+  DCHECK(request_context_getter_);
   context()->GetIDBFactory()->DeleteDatabase(
-      params.name, request_context_,
+      params.name, request_context_getter_,
       new IndexedDBCallbacks(this, params.ipc_thread_id,
                              params.ipc_callbacks_id),
       params.origin, indexed_db_path);
 }
 
 // OnPutHelper exists only to allow us to hop threads while holding a reference
 // to the IndexedDBDispatcherHost.
 void IndexedDBDispatcherHost::OnPutHelper(
     const IndexedDBHostMsg_DatabasePut_Params& params,
     std::vector<storage::BlobDataHandle*> handles) {
@@ skipping 675 matching lines @@
     DLOG(ERROR) << "Unable to reset prefetch";
 }
 
 void IndexedDBDispatcherHost::CursorDispatcherHost::OnDestroyed(
     int32_t ipc_object_id) {
   DCHECK(parent_->context()->TaskRunner()->RunsTasksOnCurrentThread());
   parent_->DestroyObject(&map_, ipc_object_id);
 }
 
 }  // namespace content