content/browser/loader/sync_resource_handler.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/loader/sync_resource_handler.h"
   6
   7 #include "base/logging.h"
   8 #include "content/browser/devtools/devtools_netlog_observer.h"
   9 #include "content/browser/loader/resource_dispatcher_host_impl.h"
  10 #include "content/browser/loader/resource_message_filter.h"
  11 #include "content/browser/loader/resource_request_info_impl.h"
  12 #include "content/common/resource_messages.h"
  13 #include "content/public/browser/resource_dispatcher_host_delegate.h"
  14 #include "content/public/browser/resource_request_info.h"
  15 #include "net/base/io_buffer.h"
  16 #include "net/http/http_response_headers.h"
  17 #include "net/url_request/redirect_info.h"
  18
  19 namespace content {
  20
  21 SyncResourceHandler::SyncResourceHandler(
  22     net::URLRequest* request,
  23     IPC::Message* result_message,
  24     ResourceDispatcherHostImpl* resource_dispatcher_host)
  25     : ResourceHandler(request),
  26       read_buffer_(new net::IOBuffer(kReadBufSize)),
  27       result_message_(result_message),
  28       rdh_(resource_dispatcher_host),
  29       total_transfer_size_(0) {
  30   result_.final_url = request->url();
  31 }
  32
  33 SyncResourceHandler::~SyncResourceHandler() {
  34   if (result_message_) {
  35     result_message_->set_reply_error();
  36     ResourceMessageFilter* filter = GetFilter();
  37     // If the filter doesn't exist at this point, the process has died and isn't
  38     // waiting for the result message anymore.
  39     if (filter)
  40       filter->Send(result_message_);
  41   }
  42 }
  43
  44 bool SyncResourceHandler::OnUploadProgress(uint64 position, uint64 size) {
  45   return true;
  46 }
  47
  48 bool SyncResourceHandler::OnRequestRedirected(
  49     const net::RedirectInfo& redirect_info,
  50     ResourceResponse* response,
  51     bool* defer) {
  52   if (rdh_->delegate()) {
  53     rdh_->delegate()->OnRequestRedirected(
  54         redirect_info.new_url, request(), GetRequestInfo()->GetContext(),
  55         response);
  56   }
  57
  58   DevToolsNetLogObserver::PopulateResponseInfo(request(), response);
  59   // TODO(darin): It would be much better if this could live in WebCore, but
  60   // doing so requires API changes at all levels.  Similar code exists in
  61   // WebCore/platform/network/cf/ResourceHandleCFNet.cpp :-(
  62   if (redirect_info.new_url.GetOrigin() != result_.final_url.GetOrigin()) {
  63     LOG(ERROR) << "Cross origin redirect denied";
  64     return false;
  65   }
  66   result_.final_url = redirect_info.new_url;
  67
  68   total_transfer_size_ += request()->GetTotalReceivedBytes();
  69   return true;
  70 }
  71
  72 bool SyncResourceHandler::OnResponseStarted(
  73     ResourceResponse* response,
  74     bool* defer) {
  75   const ResourceRequestInfoImpl* info = GetRequestInfo();
  76   if (!info->filter())
  77     return false;
  78
  79   if (rdh_->delegate()) {
  80     rdh_->delegate()->OnResponseStarted(
  81         request(), info->GetContext(), response, info->filter());
  82   }
  83
  84   DevToolsNetLogObserver::PopulateResponseInfo(request(), response);
  85
  86   // We don't care about copying the status here.
  87   result_.headers = response->head.headers;
  88   result_.mime_type = response->head.mime_type;
  89   result_.charset = response->head.charset;
  90   result_.download_file_path = response->head.download_file_path;
  91   result_.request_time = response->head.request_time;
  92   result_.response_time = response->head.response_time;
  93   result_.load_timing = response->head.load_timing;
  94   result_.devtools_info = response->head.devtools_info;
  95   return true;
  96 }
  97
  98 bool SyncResourceHandler::OnWillStart(const GURL& url, bool* defer) {
  99   return true;
 100 }
 101
 102 bool SyncResourceHandler::OnBeforeNetworkStart(const GURL& url, bool* defer) {
 103   return true;
 104 }
 105
 106 bool SyncResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
 107                                      int* buf_size,
 108                                      int min_size) {
 109   DCHECK(min_size == -1);
 110   *buf = read_buffer_.get();
 111   *buf_size = kReadBufSize;
 112   return true;
 113 }
 114
 115 bool SyncResourceHandler::OnReadCompleted(int bytes_read, bool* defer) {
 116   if (!bytes_read)
 117     return true;
 118   result_.data.append(read_buffer_->data(), bytes_read);
 119   return true;
 120 }
 121
 122 void SyncResourceHandler::OnResponseCompleted(
 123     const net::URLRequestStatus& status,
 124     const std::string& security_info,
 125     bool* defer) {
 126   ResourceMessageFilter* filter = GetFilter();
 127   if (!filter)
 128     return;
 129
 130   result_.error_code = status.error();
 131
 132   int total_transfer_size = request()->GetTotalReceivedBytes();
 133   result_.encoded_data_length = total_transfer_size_ + total_transfer_size;
 134
 135   ResourceHostMsg_SyncLoad::WriteReplyParams(result_message_, result_);
 136   filter->Send(result_message_);
 137   result_message_ = NULL;
 138   return;
 139 }
 140
 141 void SyncResourceHandler::OnDataDownloaded(int bytes_downloaded) {
 142   // Sync requests don't involve ResourceMsg_DataDownloaded messages
 143   // being sent back to renderers as progress is made.
 144 }
 145
 146 }  // namespace content