Stop using ScopedAllowIO in content::ResourceDispatcherHostImpl

content/browser/renderer_host/resource_dispatcher_host_impl.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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/browser/renderer_host/resource_dispatcher_host_impl.h"
 
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/alias.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/shared_memory.h"
 #include "base/stl_util.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
-#include "base/threading/thread_restrictions.h"
 #include "content/browser/appcache/chrome_appcache_service.h"
 #include "content/browser/cert_store_impl.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/cross_site_request_manager.h"
 #include "content/browser/download/download_file_manager.h"
 #include "content/browser/download/download_resource_handler.h"
 #include "content/browser/download/save_file_manager.h"
 #include "content/browser/download/save_file_resource_handler.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
 #include "content/browser/plugin_service_impl.h"
@@ skipping 315 matching lines @@
 
 ResourceDispatcherHostImpl::ResourceDispatcherHostImpl()
     : download_file_manager_(new DownloadFileManager(NULL)),
       save_file_manager_(new SaveFileManager()),
       request_id_(-1),
       is_shutdown_(false),
       max_outstanding_requests_cost_per_process_(
           kMaxOutstandingRequestsCostPerProcess),
       filter_(NULL),
       delegate_(NULL),
-      allow_cross_origin_auth_prompt_(false) {
+      allow_cross_origin_auth_prompt_(false),
+      weak_ptr_factory_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!g_resource_dispatcher_host);
   g_resource_dispatcher_host = this;
 
   GetContentClient()->browser()->ResourceDispatcherHostCreated();
 
   ANNOTATE_BENIGN_RACE(
       &last_user_gesture_time_,
       "We don't care about the precise value, see http://crbug.com/92889");
 
@@ skipping 425 matching lines @@
        iter != blocked_loaders_map_.end(); ++iter) {
     std::pair<std::set<ProcessRouteIDs>::iterator, bool> result =
         ids.insert(iter->first);
     // We should not have duplicates.
     DCHECK(result.second);
   }
   for (std::set<ProcessRouteIDs>::const_iterator iter = ids.begin();
        iter != ids.end(); ++iter) {
     CancelBlockedRequestsForRoute(iter->first, iter->second);
   }
+
+  weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 bool ResourceDispatcherHostImpl::OnMessageReceived(
     const IPC::Message& message,
     ResourceMessageFilter* filter,
     bool* message_was_ok) {
   filter_ = filter;
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_EX(ResourceDispatcherHostImpl, message, *message_was_ok)
     IPC_MESSAGE_HANDLER(ResourceHostMsg_RequestResource, OnRequestResource)
@@ skipping 18 matching lines @@
   }
 
   filter_ = NULL;
   return handled;
 }
 
 void ResourceDispatcherHostImpl::OnRequestResource(
     const IPC::Message& message,
     int request_id,
     const ResourceHostMsg_Request& request_data) {
-  BeginRequest(request_id, request_data, NULL, message.routing_id());
+  PrepareToBeginRequest(request_id, request_data, NULL, message.routing_id());
 }
 
 // Begins a resource request with the given params on behalf of the specified
 // child process.  Responses will be dispatched through the given receiver. The
 // process ID is used to lookup WebContentsImpl from routing_id's in the case of
 // a request from a renderer.  request_context is the cookie/cache context to be
 // used for this request.
 //
 // If sync_result is non-null, then a SyncLoad reply will be generated, else
 // a normal asynchronous set of response messages will be generated.
 void ResourceDispatcherHostImpl::OnSyncLoad(
     int request_id,
     const ResourceHostMsg_Request& request_data,
     IPC::Message* sync_result) {
-  BeginRequest(request_id, request_data, sync_result,
-               sync_result->routing_id());
+  PrepareToBeginRequest(request_id, request_data, sync_result,
+                        sync_result->routing_id());
+}
+
+void ResourceDispatcherHostImpl::PrepareToBeginRequest(
+    int request_id,
+    const ResourceHostMsg_Request& request_data,
+    IPC::Message* sync_result,
+    int route_id) {
+  if (!is_shutdown_ && request_data.upload_data) {
+    ResourceContext* resource_context = filter_->resource_context();
+    // http://crbug.com/90971
+    CHECK(ContainsKey(active_resource_contexts_, resource_context));
+
+    // Might need to resolve the blob references in the upload data.
+    GetBlobStorageControllerForResourceContext(resource_context)->
+        ResolveBlobReferencesInUploadData(request_data.upload_data.get());
+
+    // BeginRequest() will be called later with upload_size.
+    request_data.upload_data->GetContentLength(
+        base::Bind(&ResourceDispatcherHostImpl::BeginRequest,

[darin (slow to review), 2012/07/31 19:29:46]

note: The ResourceDispatcherHostImpl out-lives the IO thread, so you can use
Unretained here.

+                   weak_ptr_factory_.GetWeakPtr(),
+                   scoped_refptr<ResourceMessageFilter>(filter_),
+                   request_id,
+                   request_data,
+                   sync_result,
+                   route_id));
+  } else {  // There is no upload data.
+    const uint64 upload_size = 0;
+    BeginRequest(
+        filter_, request_id, request_data, sync_result, route_id, upload_size);
+  }
 }
 
 void ResourceDispatcherHostImpl::BeginRequest(
+    scoped_refptr<ResourceMessageFilter> filter,
     int request_id,
     const ResourceHostMsg_Request& request_data,
     IPC::Message* sync_result,  // only valid for sync
-    int route_id) {
-  ProcessType process_type = filter_->process_type();
-  int child_id = filter_->child_id();
+    int route_id,
+    uint64 upload_size) {
+  ProcessType process_type = filter->process_type();
+  int child_id = filter->child_id();
 
   // If we crash here, figure out what URL the renderer was requesting.
   // http://crbug.com/91398
   char url_buf[128];
   base::strlcpy(url_buf, request_data.url.spec().c_str(), arraysize(url_buf));
   base::debug::Alias(url_buf);
 
   // If the request that's coming in is being transferred from another process,
   // we want to reuse and resume the old loader rather than start a new one.
   linked_ptr<ResourceLoader> deferred_loader;
   {
     LoaderMap::iterator it = pending_loaders_.find(
         GlobalRequestID(request_data.transferred_request_child_id,
                         request_data.transferred_request_request_id));
     if (it != pending_loaders_.end()) {
       if (it->second->is_transferring()) {
         deferred_loader = it->second;
         pending_loaders_.erase(it);
       } else {
         RecordAction(UserMetricsAction("BadMessageTerminate_RDH"));
-        filter_->BadMessageReceived();
+        filter->BadMessageReceived();
         return;
       }
     }
   }
 
-  ResourceContext* resource_context = filter_->resource_context();
+  ResourceContext* resource_context = filter->resource_context();
   // http://crbug.com/90971
   CHECK(ContainsKey(active_resource_contexts_, resource_context));
 
-  // Might need to resolve the blob references in the upload data.
-  if (request_data.upload_data) {
-    GetBlobStorageControllerForResourceContext(resource_context)->
-        ResolveBlobReferencesInUploadData(request_data.upload_data.get());
-  }
-
   if (is_shutdown_ ||
       !ShouldServiceRequest(process_type, child_id, request_data)) {
-    AbortRequestBeforeItStarts(filter_, sync_result, route_id, request_id);
+    AbortRequestBeforeItStarts(filter, sync_result, route_id, request_id);
     return;
   }
 
   const Referrer referrer(MaybeStripReferrer(request_data.referrer),
                           request_data.referrer_policy);
 
   // Allow the observer to block/handle the request.
   if (delegate_ && !delegate_->ShouldBeginRequest(child_id,
                                                   route_id,
                                                   request_data.method,
                                                   request_data.url,
                                                   request_data.resource_type,
                                                   resource_context,
                                                   referrer)) {
-    AbortRequestBeforeItStarts(filter_, sync_result, route_id, request_id);
+    AbortRequestBeforeItStarts(filter, sync_result, route_id, request_id);
     return;
   }
 
   int load_flags =
       BuildLoadFlagsForRequest(request_data, child_id, sync_result != NULL);
 
   // Construct the request.
   scoped_ptr<net::URLRequest> new_request;
   net::URLRequest* request;
   if (deferred_loader.get()) {
     request = deferred_loader->request();
 
     // Give the ResourceLoader (or any of the ResourceHandlers held by it) a
     // chance to reset some state before we complete the transfer.
     deferred_loader->WillCompleteTransfer();
   } else {
     new_request.reset(new net::URLRequest(
         request_data.url,
         NULL,
-        filter_->GetURLRequestContext(request_data.resource_type)));
+        filter->GetURLRequestContext(request_data.resource_type)));
     request = new_request.get();
 
     request->set_method(request_data.method);
     request->set_first_party_for_cookies(request_data.first_party_for_cookies);
     request->set_referrer(referrer.url.spec());
     webkit_glue::ConfigureURLRequestForReferrerPolicy(request,
                                                       referrer.policy);
     net::HttpRequestHeaders headers;
     headers.AddHeadersFromString(request_data.headers);
     request->SetExtraRequestHeaders(headers);
   }
 
   // TODO(darin): Do we really need all of these URLRequest setters in the
   // transferred navigation case?
 
   request->set_load_flags(load_flags);
 
   request->set_priority(DetermineRequestPriority(request_data.resource_type));
 
   // Set upload data.
-  uint64 upload_size = 0;
-  if (request_data.upload_data) {
+  if (request_data.upload_data)
     request->set_upload(request_data.upload_data);
-    // This results in performing file IO. crbug.com/112607.
-    base::ThreadRestrictions::ScopedAllowIO allow_io;
-    upload_size = request_data.upload_data->GetContentLengthSync();
-  }
 
   bool allow_download = request_data.allow_download &&
       ResourceType::IsFrame(request_data.resource_type);
 
   // Make extra info and read footer (contains request ID).
   ResourceRequestInfoImpl* extra_info =
       new ResourceRequestInfoImpl(
           process_type,
           child_id,
           route_id,
@@ skipping 24 matching lines @@
 
   // Have the appcache associate its extra info with the request.
   appcache::AppCacheInterceptor::SetExtraRequestInfo(
       request, ResourceContext::GetAppCacheService(resource_context), child_id,
       request_data.appcache_host_id, request_data.resource_type);
 
   // Construct the IPC resource handler.
   scoped_ptr<ResourceHandler> handler;
   if (sync_result) {
     handler.reset(new SyncResourceHandler(
-        filter_, request, sync_result, this));
+        filter, request, sync_result, this));
   } else {
     handler.reset(new AsyncResourceHandler(
-        filter_, route_id, request, this));
+        filter, route_id, request, this));
   }
 
   // The RedirectToFileResourceHandler depends on being next in the chain.
   if (request_data.download_to_file) {
     handler.reset(
         new RedirectToFileResourceHandler(handler.Pass(), child_id, this));
   }
 
   // Install a CrossSiteResourceHandler if this request is coming from a
   // RenderViewHost with a pending cross-site request.  We only check this for
@@ skipping 690 matching lines @@
 
   return i->second.get();
 }
 
 ResourceLoader* ResourceDispatcherHostImpl::GetLoader(int child_id,
                                                       int request_id) const {
   return GetLoader(GlobalRequestID(child_id, request_id));
 }
 
 }  // namespace content