Introduce ResourceRequesterInfo to abstract the requester of resource request

content/browser/loader/async_resource_handler.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/loader/async_resource_handler.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/debug/alias.h"
 #include "base/feature_list.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/shared_memory.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "content/browser/loader/netlog_observer.h"
 #include "content/browser/loader/resource_buffer.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
-#include "content/browser/loader/resource_message_filter.h"
 #include "content/browser/loader/resource_request_info_impl.h"
 #include "content/common/resource_messages.h"
 #include "content/common/resource_request_completion_status.h"
 #include "content/common/view_messages.h"
+#include "content/public/browser/browser_message_filter.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
 #include "content/public/common/content_features.h"
 #include "content/public/common/resource_response.h"
 #include "ipc/ipc_message_macros.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/redirect_info.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
@@ skipping 171 matching lines @@
       allocation_size_(0),
       did_defer_(false),
       has_checked_for_sufficient_resources_(false),
       sent_received_response_msg_(false),
       sent_data_buffer_msg_(false),
       inlining_helper_(new InliningHelper),
       last_upload_position_(0),
       waiting_for_upload_progress_ack_(false),
       reported_transfer_size_(0),
       reported_encoded_body_length_(0) {
+  DCHECK(GetRequestInfo()->requester_info().IsRenderer());
   InitializeResourceBufferConstants();
 }
 
 AsyncResourceHandler::~AsyncResourceHandler() {
   if (has_checked_for_sufficient_resources_)
     rdh_->FinishedWithResourcesForRequest(request());
 }
 
 bool AsyncResourceHandler::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
@@ skipping 24 matching lines @@
       ResumeIfDeferred();
   }
 }
 
 void AsyncResourceHandler::OnUploadProgressACK(int request_id) {
   waiting_for_upload_progress_ack_ = false;
 }
 
 void AsyncResourceHandler::ReportUploadProgress() {
   DCHECK(GetRequestInfo()->is_upload_progress_enabled());
+  DCHECK(GetRequestInfo()->requester_info().IsRenderer());
   if (waiting_for_upload_progress_ack_)
     return;  // Send one progress event at a time.
 
   net::UploadProgress progress = request()->GetUploadProgress();
   if (!progress.size())
     return;  // Nothing to upload.
 
   if (progress.position() == last_upload_position_)
     return;  // No progress made since last time.
 
   const uint64_t kHalfPercentIncrements = 200;
   const TimeDelta kOneSecond = TimeDelta::FromMilliseconds(1000);
 
   uint64_t amt_since_last = progress.position() - last_upload_position_;
   TimeDelta time_since_last = TimeTicks::Now() - last_upload_ticks_;
 
   bool is_finished = (progress.size() == progress.position());
   bool enough_new_progress =
       (amt_since_last > (progress.size() / kHalfPercentIncrements));
   bool too_much_time_passed = time_since_last > kOneSecond;
 
   if (is_finished || enough_new_progress || too_much_time_passed) {
-    ResourceMessageFilter* filter = GetFilter();
+    BrowserMessageFilter* filter = GetFilter();
     if (filter) {
       filter->Send(
         new ResourceMsg_UploadProgress(GetRequestID(),
                                        progress.position(),
                                        progress.size()));
     }
     waiting_for_upload_progress_ack_ = true;
     last_upload_ticks_ = TimeTicks::Now();
     last_upload_position_ = progress.position();
   }
 }
 
 bool AsyncResourceHandler::OnRequestRedirected(
     const net::RedirectInfo& redirect_info,
     ResourceResponse* response,
     bool* defer) {
-  const ResourceRequestInfoImpl* info = GetRequestInfo();
-  if (!info->filter())
+  DCHECK(GetRequestInfo()->requester_info().IsRenderer());
+  BrowserMessageFilter* filter = GetFilter();
+  if (!filter)
     return false;
 
   *defer = did_defer_ = true;
   OnDefer();
 
   NetLogObserver::PopulateResponseInfo(request(), response);
   response->head.encoded_data_length = request()->GetTotalReceivedBytes();
   reported_transfer_size_ = 0;
   response->head.request_start = request()->creation_time();
   response->head.response_start = TimeTicks::Now();
   // TODO(davidben): Is it necessary to pass the new first party URL for
   // cookies? The only case where it can change is top-level navigation requests
   // and hopefully those will eventually all be owned by the browser. It's
   // possible this is still needed while renderer-owned ones exist.
-  return info->filter()->Send(new ResourceMsg_ReceivedRedirect(
+  return filter->Send(new ResourceMsg_ReceivedRedirect(
       GetRequestID(), redirect_info, response->head));
 }
 
 bool AsyncResourceHandler::OnResponseStarted(ResourceResponse* response,
                                              bool* defer) {
+  DCHECK(GetRequestInfo()->requester_info().IsRenderer());
   // For changes to the main frame, inform the renderer of the new URL's
   // per-host settings before the request actually commits.  This way the
   // renderer will be able to set these precisely at the time the
   // request commits, avoiding the possibility of e.g. zooming the old content
   // or of having to layout the new content twice.
 
   response_started_ticks_ = base::TimeTicks::Now();
 
   progress_timer_.Stop();
   const ResourceRequestInfoImpl* info = GetRequestInfo();
-  if (!info->filter())
+  BrowserMessageFilter* filter = GetFilter();
+  if (!filter)
     return false;
 
   // We want to send a final upload progress message prior to sending the
   // response complete message even if we're waiting for an ack to to a
   // previous upload progress message.
   if (info->is_upload_progress_enabled()) {
     waiting_for_upload_progress_ack_ = false;
     ReportUploadProgress();
   }
 
   if (rdh_->delegate()) {
     rdh_->delegate()->OnResponseStarted(request(), info->GetContext(),
                                         response);
   }
 
   NetLogObserver::PopulateResponseInfo(request(), response);
   response->head.encoded_data_length = request()->raw_header_size();
 
   // If the parent handler downloaded the resource to a file, grant the child
   // read permissions on it.
   if (!response->head.download_file_path.empty()) {
     rdh_->RegisterDownloadedTempFile(
         info->GetChildID(), info->GetRequestID(),
         response->head.download_file_path);
   }
 
   response->head.request_start = request()->creation_time();
   response->head.response_start = TimeTicks::Now();
-  info->filter()->Send(new ResourceMsg_ReceivedResponse(GetRequestID(),
-                                                        response->head));
+  filter->Send(
+      new ResourceMsg_ReceivedResponse(GetRequestID(), response->head));
   sent_received_response_msg_ = true;
 
   if (request()->response_info().metadata.get()) {
     std::vector<char> copy(request()->response_info().metadata->data(),
                            request()->response_info().metadata->data() +
                                request()->response_info().metadata->size());
-    info->filter()->Send(new ResourceMsg_ReceivedCachedMetadata(GetRequestID(),
-                                                                copy));
+    filter->Send(new ResourceMsg_ReceivedCachedMetadata(GetRequestID(), copy));
   }
 
   inlining_helper_->OnResponseReceived(*response);
   return true;
 }
 
 bool AsyncResourceHandler::OnWillStart(const GURL& url, bool* defer) {
+  DCHECK(GetRequestInfo()->requester_info().IsRenderer());
   if (GetRequestInfo()->is_upload_progress_enabled() &&
       request()->has_upload()) {
     ReportUploadProgress();
     progress_timer_.Start(
         FROM_HERE,
         base::TimeDelta::FromMilliseconds(kUploadProgressIntervalMsec),
         this,
         &AsyncResourceHandler::ReportUploadProgress);
   }
   return true;
 }
 
 bool AsyncResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
                                       int* buf_size,
                                       int min_size) {
+  DCHECK(GetRequestInfo()->requester_info().IsRenderer());
   DCHECK_EQ(-1, min_size);
 
   if (!CheckForSufficientResource())
     return false;
 
   // Return early if InliningHelper allocates the buffer, so that we should
   // inline the data into the IPC message without allocating SharedMemory.
   if (inlining_helper_->PrepareInlineBufferIfApplicable(buf, buf_size))
     return true;
 
   if (!EnsureResourceBufferIsInitialized())
     return false;
 
   DCHECK(buffer_->CanAllocate());
   char* memory = buffer_->Allocate(&allocation_size_);
   CHECK(memory);
 
   *buf = new DependentIOBuffer(buffer_.get(), memory);
   *buf_size = allocation_size_;
 
   return true;
 }
 
 bool AsyncResourceHandler::OnReadCompleted(int bytes_read, bool* defer) {
+  DCHECK(GetRequestInfo()->requester_info().IsRenderer());
   DCHECK_GE(bytes_read, 0);
 
   if (!bytes_read)
     return true;
 
-  ResourceMessageFilter* filter = GetFilter();
+  BrowserMessageFilter* filter = GetFilter();
   if (!filter)
     return false;
 
   int encoded_data_length = CalculateEncodedDataLengthToReport();
   if (!first_chunk_read_)
     encoded_data_length -= request()->raw_header_size();
 
   int encoded_body_length = CalculateEncodedBodyLengthToReport();
   first_chunk_read_ = true;
 
@@ skipping 25 matching lines @@
 
   if (!buffer_->CanAllocate()) {
     *defer = did_defer_ = true;
     OnDefer();
   }
 
   return true;
 }
 
 void AsyncResourceHandler::OnDataDownloaded(int bytes_downloaded) {
+  DCHECK(GetRequestInfo()->requester_info().IsRenderer());
   int encoded_data_length = CalculateEncodedDataLengthToReport();
 
-  ResourceMessageFilter* filter = GetFilter();
+  BrowserMessageFilter* filter = GetFilter();
   if (filter) {
     filter->Send(new ResourceMsg_DataDownloaded(
         GetRequestID(), bytes_downloaded, encoded_data_length));
   }
 }
 
 void AsyncResourceHandler::OnResponseCompleted(
     const net::URLRequestStatus& status,
     bool* defer) {
+  DCHECK(GetRequestInfo()->requester_info().IsRenderer());
   const ResourceRequestInfoImpl* info = GetRequestInfo();
-  if (!info->filter())
+  BrowserMessageFilter* filter = GetFilter();
+  if (!filter)
     return;
 
   // If we crash here, figure out what URL the renderer was requesting.
   // http://crbug.com/107692
   char url_buf[128];
   base::strlcpy(url_buf, request()->url().spec().c_str(), arraysize(url_buf));
   base::debug::Alias(url_buf);
 
   // TODO(gavinp): Remove this CHECK when we figure out the cause of
   // http://crbug.com/124680 . This check mirrors closely check in
@@ skipping 12 matching lines @@
   // the ERR_ABORTED error code).
   DCHECK(!was_ignored_by_handler || error_code == net::ERR_ABORTED);
 
   ResourceRequestCompletionStatus request_complete_data;
   request_complete_data.error_code = error_code;
   request_complete_data.was_ignored_by_handler = was_ignored_by_handler;
   request_complete_data.exists_in_cache = request()->response_info().was_cached;
   request_complete_data.completion_time = TimeTicks::Now();
   request_complete_data.encoded_data_length =
       request()->GetTotalReceivedBytes();
-  info->filter()->Send(
+  filter->Send(
       new ResourceMsg_RequestComplete(GetRequestID(), request_complete_data));
 
   if (status.is_success())
     RecordHistogram();
 }
 
 bool AsyncResourceHandler::EnsureResourceBufferIsInitialized() {
   DCHECK(has_checked_for_sufficient_resources_);
 
   if (buffer_.get() && buffer_->IsInitialized())
@@ skipping 59 matching lines @@
   } else {
     UMA_HISTOGRAM_CUSTOM_COUNTS(
         "Net.ResourceLoader.ResponseStartToEnd.Over_512kB",
         elapsed_time, 1, 100000, 100);
   }
 
   inlining_helper_->RecordHistogram(elapsed_time);
 }
 
 }  // namespace content