Cleanup ResourceDispatcher::PendingRequestInfo

content/child/resource_dispatcher.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/child/resource_dispatcher.h"
 
 #include <utility>
 
@@ skipping 111 matching lines @@
       return true;
     }
   }
 
   DispatchMessage(message);
   return true;
 }
 
 ResourceDispatcher::PendingRequestInfo*
 ResourceDispatcher::GetPendingRequestInfo(int request_id) {
-  PendingRequestList::iterator it = pending_requests_.find(request_id);
+  PendingRequestMap::iterator it = pending_requests_.find(request_id);
   if (it == pending_requests_.end()) {
     // This might happen for kill()ed requests on the webkit end.
     return NULL;
   }
-  return &(it->second);
+  return it->second.get();
 }
 
 void ResourceDispatcher::OnUploadProgress(int request_id,
                                           int64_t position,
                                           int64_t size) {
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
   if (!request_info)
     return;
 
   request_info->peer->OnUploadProgress(position, size);
@@ skipping 183 matching lines @@
     // potentially remove it.
     request_info = GetPendingRequestInfo(request_id);
     if (!request_info)
       return;
     // We update the response_url here so that we can send it to
     // SiteIsolationStatsGatherer later when OnReceivedResponse is called.
     request_info->response_url = redirect_info.new_url;
     request_info->pending_redirect_message.reset(
         new ResourceHostMsg_FollowRedirect(request_id));
     if (!request_info->is_deferred) {
-      FollowPendingRedirect(request_id, *request_info);
+      FollowPendingRedirect(request_id, request_info);
     }
   } else {
     Cancel(request_id);
   }
 }
 
 void ResourceDispatcher::FollowPendingRedirect(
     int request_id,
-    PendingRequestInfo& request_info) {
-  IPC::Message* msg = request_info.pending_redirect_message.release();
+    PendingRequestInfo* request_info) {
+  IPC::Message* msg = request_info->pending_redirect_message.release();
   if (msg)
     message_sender_->Send(msg);
 }
 
 void ResourceDispatcher::OnRequestComplete(
     int request_id,
     const ResourceMsg_RequestCompleteData& request_complete_data) {
   TRACE_EVENT0("loader", "ResourceDispatcher::OnRequestComplete");
 
   PendingRequestInfo* request_info = GetPendingRequestInfo(request_id);
@@ skipping 52 matching lines @@
   RequestPeer* peer = request_info->peer;
   peer->OnCompletedRequest(request_complete_data.error_code,
                            request_complete_data.was_ignored_by_handler,
                            request_complete_data.exists_in_cache,
                            request_complete_data.security_info,
                            renderer_completion_time,
                            request_complete_data.encoded_data_length);
 }
 
 bool ResourceDispatcher::RemovePendingRequest(int request_id) {
-  PendingRequestList::iterator it = pending_requests_.find(request_id);
+  PendingRequestMap::iterator it = pending_requests_.find(request_id);
   if (it == pending_requests_.end())
     return false;
 
-  PendingRequestInfo& request_info = it->second;
+  PendingRequestInfo* request_info = it->second.get();
 
-  bool release_downloaded_file = request_info.download_to_file;
+  bool release_downloaded_file = request_info->download_to_file;
 
-  ReleaseResourcesInMessageQueue(&request_info.deferred_message_queue);
+  ReleaseResourcesInMessageQueue(&request_info->deferred_message_queue);
   pending_requests_.erase(it);
 
   if (release_downloaded_file) {
     message_sender_->Send(
         new ResourceHostMsg_ReleaseDownloadedFile(request_id));
   }
 
   if (resource_scheduling_filter_.get())
     resource_scheduling_filter_->ClearRequestIdTaskRunner(request_id);
 
   return true;
 }
 
 void ResourceDispatcher::Cancel(int request_id) {
-  PendingRequestList::iterator it = pending_requests_.find(request_id);
+  PendingRequestMap::iterator it = pending_requests_.find(request_id);
   if (it == pending_requests_.end()) {
     DVLOG(1) << "unknown request";
     return;
   }
 
   // |completion_time.is_null()| is a proxy for OnRequestComplete never being
   // called.
   // TODO(csharrison): Remove this code when crbug.com/557430 is resolved.
   // ~250,000 ERR_ABORTED coming into canary with |request_time| < 100ms. Sample
   // by .01% to get something reasonable.
-  PendingRequestInfo& info = it->second;
+  const PendingRequestInfo& info = *it->second;
   int64_t request_time =
       (base::TimeTicks::Now() - info.request_start).InMilliseconds();
   if (info.resource_type == ResourceType::RESOURCE_TYPE_MAIN_FRAME &&
       info.completion_time.is_null() && request_time < 100 &&
       base::RandDouble() < .0001) {
     static bool should_dump = true;
     if (should_dump) {
       char url_copy[256] = {0};
       strncpy(url_copy, info.response_url.spec().c_str(),
               sizeof(url_copy));
       base::debug::Alias(&url_copy);
       base::debug::Alias(&request_time);
       base::debug::DumpWithoutCrashing();
       should_dump = false;
     }
   }
   // Cancel the request, and clean it up so the bridge will receive no more
   // messages.
   message_sender_->Send(new ResourceHostMsg_CancelRequest(request_id));
   RemovePendingRequest(request_id);
 }
 
 void ResourceDispatcher::SetDefersLoading(int request_id, bool value) {
-  PendingRequestList::iterator it = pending_requests_.find(request_id);
+  PendingRequestMap::iterator it = pending_requests_.find(request_id);
   if (it == pending_requests_.end()) {
     DLOG(ERROR) << "unknown request";
     return;
   }
-  PendingRequestInfo& request_info = it->second;
+  PendingRequestInfo* request_info = it->second.get();
   if (value) {
-    request_info.is_deferred = value;
-  } else if (request_info.is_deferred) {
-    request_info.is_deferred = false;
+    request_info->is_deferred = value;
+  } else if (request_info->is_deferred) {
+    request_info->is_deferred = false;
 
     FollowPendingRedirect(request_id, request_info);
 
     main_thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&ResourceDispatcher::FlushDeferredMessages,
                               weak_factory_.GetWeakPtr(), request_id));
   }
 }
 
 void ResourceDispatcher::DidChangePriority(int request_id,
@@ skipping 13 matching lines @@
     DCHECK(!request_info->threaded_data_provider);
     request_info->threaded_data_provider = new ThreadedDataProvider(
         request_id, threaded_data_receiver, request_info->buffer,
         request_info->buffer_size, main_thread_task_runner_);
     return true;
   }
 
   return false;
 }
 
-ResourceDispatcher::PendingRequestInfo::PendingRequestInfo()
-    : peer(NULL),
-      threaded_data_provider(NULL),
-      resource_type(RESOURCE_TYPE_SUB_RESOURCE),
-      is_deferred(false),
-      download_to_file(false),
-      buffer_size(0),
-      data_offset(-1) {
-}
-
 ResourceDispatcher::PendingRequestInfo::PendingRequestInfo(
     RequestPeer* peer,
     ResourceType resource_type,
     int origin_pid,
     const GURL& frame_origin,
     const GURL& request_url,
     bool download_to_file)
     : peer(peer),
-      threaded_data_provider(NULL),
       resource_type(resource_type),
       origin_pid(origin_pid),
-      is_deferred(false),
       url(request_url),
       frame_origin(frame_origin),
       response_url(request_url),
       download_to_file(download_to_file),
-      request_start(base::TimeTicks::Now()),
-      data_offset(-1) {
+      request_start(base::TimeTicks::Now()) {
 }
 
 ResourceDispatcher::PendingRequestInfo::~PendingRequestInfo() {
   if (threaded_data_provider)
     threaded_data_provider->Stop();
 }
 
 void ResourceDispatcher::DispatchMessage(const IPC::Message& message) {
   IPC_BEGIN_MESSAGE_MAP(ResourceDispatcher, message)
     IPC_MESSAGE_HANDLER(ResourceMsg_UploadProgress, OnUploadProgress)
     IPC_MESSAGE_HANDLER(ResourceMsg_ReceivedResponse, OnReceivedResponse)
     IPC_MESSAGE_HANDLER(ResourceMsg_ReceivedCachedMetadata,
                         OnReceivedCachedMetadata)
     IPC_MESSAGE_HANDLER(ResourceMsg_ReceivedRedirect, OnReceivedRedirect)
     IPC_MESSAGE_HANDLER(ResourceMsg_SetDataBuffer, OnSetDataBuffer)
     IPC_MESSAGE_HANDLER(ResourceMsg_DataReceivedDebug, OnReceivedDataDebug)
     IPC_MESSAGE_HANDLER(ResourceMsg_DataReceived, OnReceivedData)
     IPC_MESSAGE_HANDLER(ResourceMsg_DataDownloaded, OnDownloadedData)
     IPC_MESSAGE_HANDLER(ResourceMsg_RequestComplete, OnRequestComplete)
   IPC_END_MESSAGE_MAP()
 }
 
 void ResourceDispatcher::FlushDeferredMessages(int request_id) {
-  PendingRequestList::iterator it = pending_requests_.find(request_id);
+  PendingRequestMap::iterator it = pending_requests_.find(request_id);
   if (it == pending_requests_.end())  // The request could have become invalid.
     return;
-  PendingRequestInfo& request_info = it->second;
-  if (request_info.is_deferred)
+  PendingRequestInfo* request_info = it->second.get();
+  if (request_info->is_deferred)
     return;
   // Because message handlers could result in request_info being destroyed,
   // we need to work with a stack reference to the deferred queue.
   MessageQueue q;
-  q.swap(request_info.deferred_message_queue);
+  q.swap(request_info->deferred_message_queue);
   while (!q.empty()) {
     IPC::Message* m = q.front();
     q.pop_front();
     DispatchMessage(*m);
     delete m;
     // If this request is deferred in the context of the above message, then
     // we should honor the same and stop dispatching further messages.
     // We need to find the request again in the list as it may have completed
     // by now and the request_info instance above may be invalid.
-    PendingRequestList::iterator index = pending_requests_.find(request_id);
+    PendingRequestMap::iterator index = pending_requests_.find(request_id);
     if (index != pending_requests_.end()) {
-      PendingRequestInfo& pending_request = index->second;
-      if (pending_request.is_deferred) {
-        pending_request.deferred_message_queue.swap(q);
+      PendingRequestInfo* pending_request = index->second.get();
+      if (pending_request->is_deferred) {
+        pending_request->deferred_message_queue.swap(q);
         return;
       }
     }
   }
 }
 
 void ResourceDispatcher::StartSync(const RequestInfo& request_info,
                                    ResourceRequestBody* request_body,
                                    SyncLoadResponse* response) {
   scoped_ptr<ResourceHostMsg_Request> request =
@@ skipping 26 matching lines @@
 int ResourceDispatcher::StartAsync(const RequestInfo& request_info,
                                    ResourceRequestBody* request_body,
                                    RequestPeer* peer) {
   GURL frame_origin;
   scoped_ptr<ResourceHostMsg_Request> request =
       CreateRequest(request_info, request_body, &frame_origin);
 
   // Compute a unique request_id for this renderer process.
   int request_id = MakeRequestID();
   pending_requests_[request_id] =
-      PendingRequestInfo(peer,
+      make_scoped_ptr(new PendingRequestInfo(peer,
                          request->resource_type,
                          request->origin_pid,
                          frame_origin,
                          request->url,
-                         request_info.download_to_file);
+                         request_info.download_to_file));
 
   if (resource_scheduling_filter_.get() &&
       request_info.loading_web_task_runner) {
     resource_scheduling_filter_->SetRequestIdTaskRunner(
         request_id,
         make_scoped_ptr(request_info.loading_web_task_runner->clone()));
   }
 
   message_sender_->Send(new ResourceHostMsg_RequestResource(
       request_info.routing_id, request_id, *request));
@@ skipping 202 matching lines @@
     *frame_origin = extra_data->frame_origin();
   return request;
 }
 
 void ResourceDispatcher::SetResourceSchedulingFilter(
     scoped_refptr<ResourceSchedulingFilter> resource_scheduling_filter) {
   resource_scheduling_filter_ = resource_scheduling_filter;
 }
 
 }  // namespace content