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/async_resource_handler.h" 6 7 #include <algorithm> 8 #include <vector> 9 10 #include "base/command_line.h" 11 #include "base/containers/hash_tables.h" 12 #include "base/debug/alias.h" 13 #include "base/logging.h" 14 #include "base/memory/shared_memory.h" 15 #include "base/metrics/histogram.h" 16 #include "base/strings/string_number_conversions.h" 17 #include "content/browser/devtools/devtools_netlog_observer.h" 18 #include "content/browser/host_zoom_map_impl.h" 19 #include "content/browser/loader/resource_buffer.h" 20 #include "content/browser/loader/resource_dispatcher_host_impl.h" 21 #include "content/browser/loader/resource_message_filter.h" 22 #include "content/browser/loader/resource_request_info_impl.h" 23 #include "content/browser/resource_context_impl.h" 24 #include "content/common/resource_messages.h" 25 #include "content/common/view_messages.h" 26 #include "content/public/browser/global_request_id.h" 27 #include "content/public/browser/resource_dispatcher_host_delegate.h" 28 #include "content/public/common/resource_response.h" 29 #include "net/base/io_buffer.h" 30 #include "net/base/load_flags.h" 31 #include "net/base/net_log.h" 32 #include "net/base/net_util.h" 33 34 using base::TimeTicks; 35 36 namespace content { 37 namespace { 38 39 static int kBufferSize = 1024 * 512; 40 static int kMinAllocationSize = 1024 * 4; 41 static int kMaxAllocationSize = 1024 * 32; 42 43 void GetNumericArg(const std::string& name, int* result) { 44 const std::string& value = 45 CommandLine::ForCurrentProcess()->GetSwitchValueASCII(name); 46 if (!value.empty()) 47 base::StringToInt(value, result); 48 } 49 50 void InitializeResourceBufferConstants() { 51 static bool did_init = false; 52 if (did_init) 53 return; 54 did_init = true; 55 56 GetNumericArg("resource-buffer-size", &kBufferSize); 57 GetNumericArg("resource-buffer-min-allocation-size", &kMinAllocationSize); 58 GetNumericArg("resource-buffer-max-allocation-size", &kMaxAllocationSize); 59 } 60 61 int CalcUsedPercentage(int bytes_read, int buffer_size) { 62 double ratio = static_cast<double>(bytes_read) / buffer_size; 63 return static_cast<int>(ratio * 100.0 + 0.5); // Round to nearest integer. 64 } 65 66 } // namespace 67 68 class DependentIOBuffer : public net::WrappedIOBuffer { 69 public: 70 DependentIOBuffer(ResourceBuffer* backing, char* memory) 71 : net::WrappedIOBuffer(memory), 72 backing_(backing) { 73 } 74 private: 75 virtual ~DependentIOBuffer() {} 76 scoped_refptr<ResourceBuffer> backing_; 77 }; 78 79 AsyncResourceHandler::AsyncResourceHandler( 80 ResourceMessageFilter* filter, 81 int routing_id, 82 net::URLRequest* request, 83 ResourceDispatcherHostImpl* rdh) 84 : ResourceMessageDelegate(request), 85 filter_(filter), 86 routing_id_(routing_id), 87 request_(request), 88 rdh_(rdh), 89 pending_data_count_(0), 90 allocation_size_(0), 91 did_defer_(false), 92 has_checked_for_sufficient_resources_(false), 93 sent_received_response_msg_(false), 94 sent_first_data_msg_(false) { 95 InitializeResourceBufferConstants(); 96 } 97 98 AsyncResourceHandler::~AsyncResourceHandler() { 99 if (has_checked_for_sufficient_resources_) 100 rdh_->FinishedWithResourcesForRequest(request_); 101 } 102 103 bool AsyncResourceHandler::OnMessageReceived(const IPC::Message& message, 104 bool* message_was_ok) { 105 bool handled = true; 106 IPC_BEGIN_MESSAGE_MAP_EX(AsyncResourceHandler, message, *message_was_ok) 107 IPC_MESSAGE_HANDLER(ResourceHostMsg_FollowRedirect, OnFollowRedirect) 108 IPC_MESSAGE_HANDLER(ResourceHostMsg_DataReceived_ACK, OnDataReceivedACK) 109 IPC_MESSAGE_UNHANDLED(handled = false) 110 IPC_END_MESSAGE_MAP_EX() 111 return handled; 112 } 113 114 void AsyncResourceHandler::OnFollowRedirect( 115 int request_id, 116 bool has_new_first_party_for_cookies, 117 const GURL& new_first_party_for_cookies) { 118 if (!request_->status().is_success()) { 119 DVLOG(1) << "OnFollowRedirect for invalid request"; 120 return; 121 } 122 123 if (has_new_first_party_for_cookies) 124 request_->set_first_party_for_cookies(new_first_party_for_cookies); 125 126 ResumeIfDeferred(); 127 } 128 129 void AsyncResourceHandler::OnDataReceivedACK(int request_id) { 130 if (pending_data_count_) { 131 --pending_data_count_; 132 133 buffer_->RecycleLeastRecentlyAllocated(); 134 if (buffer_->CanAllocate()) 135 ResumeIfDeferred(); 136 } 137 } 138 139 bool AsyncResourceHandler::OnUploadProgress(int request_id, 140 uint64 position, 141 uint64 size) { 142 return filter_->Send(new ResourceMsg_UploadProgress(routing_id_, request_id, 143 position, size)); 144 } 145 146 bool AsyncResourceHandler::OnRequestRedirected(int request_id, 147 const GURL& new_url, 148 ResourceResponse* response, 149 bool* defer) { 150 *defer = did_defer_ = true; 151 152 if (rdh_->delegate()) { 153 rdh_->delegate()->OnRequestRedirected(new_url, request_, 154 filter_->resource_context(), 155 response); 156 } 157 158 DevToolsNetLogObserver::PopulateResponseInfo(request_, response); 159 response->head.request_start = request_->creation_time(); 160 response->head.response_start = TimeTicks::Now(); 161 return filter_->Send(new ResourceMsg_ReceivedRedirect( 162 routing_id_, request_id, new_url, response->head)); 163 } 164 165 bool AsyncResourceHandler::OnResponseStarted(int request_id, 166 ResourceResponse* response, 167 bool* defer) { 168 // For changes to the main frame, inform the renderer of the new URL's 169 // per-host settings before the request actually commits. This way the 170 // renderer will be able to set these precisely at the time the 171 // request commits, avoiding the possibility of e.g. zooming the old content 172 // or of having to layout the new content twice. 173 174 ResourceContext* resource_context = filter_->resource_context(); 175 if (rdh_->delegate()) { 176 rdh_->delegate()->OnResponseStarted( 177 request_, resource_context, response, filter_.get()); 178 } 179 180 DevToolsNetLogObserver::PopulateResponseInfo(request_, response); 181 182 HostZoomMap* host_zoom_map = 183 GetHostZoomMapForResourceContext(resource_context); 184 185 const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request_); 186 if (info->GetResourceType() == ResourceType::MAIN_FRAME && host_zoom_map) { 187 const GURL& request_url = request_->url(); 188 filter_->Send(new ViewMsg_SetZoomLevelForLoadingURL( 189 info->GetRouteID(), 190 request_url, host_zoom_map->GetZoomLevelForHostAndScheme( 191 request_url.scheme(), 192 net::GetHostOrSpecFromURL(request_url)))); 193 } 194 195 response->head.request_start = request_->creation_time(); 196 response->head.response_start = TimeTicks::Now(); 197 filter_->Send(new ResourceMsg_ReceivedResponse( 198 routing_id_, request_id, response->head)); 199 sent_received_response_msg_ = true; 200 201 if (request_->response_info().metadata.get()) { 202 std::vector<char> copy(request_->response_info().metadata->data(), 203 request_->response_info().metadata->data() + 204 request_->response_info().metadata->size()); 205 filter_->Send(new ResourceMsg_ReceivedCachedMetadata( 206 routing_id_, request_id, copy)); 207 } 208 209 return true; 210 } 211 212 bool AsyncResourceHandler::OnWillStart(int request_id, 213 const GURL& url, 214 bool* defer) { 215 return true; 216 } 217 218 bool AsyncResourceHandler::OnWillRead(int request_id, net::IOBuffer** buf, 219 int* buf_size, int min_size) { 220 DCHECK_EQ(-1, min_size); 221 222 if (!EnsureResourceBufferIsInitialized()) 223 return false; 224 225 DCHECK(buffer_->CanAllocate()); 226 char* memory = buffer_->Allocate(&allocation_size_); 227 CHECK(memory); 228 229 *buf = new DependentIOBuffer(buffer_.get(), memory); 230 *buf_size = allocation_size_; 231 232 UMA_HISTOGRAM_CUSTOM_COUNTS( 233 "Net.AsyncResourceHandler_SharedIOBuffer_Alloc", 234 *buf_size, 0, kMaxAllocationSize, 100); 235 return true; 236 } 237 238 bool AsyncResourceHandler::OnReadCompleted(int request_id, int bytes_read, 239 bool* defer) { 240 if (!bytes_read) 241 return true; 242 243 buffer_->ShrinkLastAllocation(bytes_read); 244 245 UMA_HISTOGRAM_CUSTOM_COUNTS( 246 "Net.AsyncResourceHandler_SharedIOBuffer_Used", 247 bytes_read, 0, kMaxAllocationSize, 100); 248 UMA_HISTOGRAM_PERCENTAGE( 249 "Net.AsyncResourceHandler_SharedIOBuffer_UsedPercentage", 250 CalcUsedPercentage(bytes_read, allocation_size_)); 251 252 if (!sent_first_data_msg_) { 253 base::SharedMemoryHandle handle; 254 int size; 255 if (!buffer_->ShareToProcess(filter_->PeerHandle(), &handle, &size)) 256 return false; 257 filter_->Send( 258 new ResourceMsg_SetDataBuffer(routing_id_, request_id, handle, size, 259 filter_->peer_pid())); 260 sent_first_data_msg_ = true; 261 } 262 263 int data_offset = buffer_->GetLastAllocationOffset(); 264 int encoded_data_length = 265 DevToolsNetLogObserver::GetAndResetEncodedDataLength(request_); 266 267 filter_->Send( 268 new ResourceMsg_DataReceived(routing_id_, request_id, data_offset, 269 bytes_read, encoded_data_length)); 270 ++pending_data_count_; 271 UMA_HISTOGRAM_CUSTOM_COUNTS( 272 "Net.AsyncResourceHandler_PendingDataCount", 273 pending_data_count_, 0, 100, 100); 274 275 if (!buffer_->CanAllocate()) { 276 UMA_HISTOGRAM_CUSTOM_COUNTS( 277 "Net.AsyncResourceHandler_PendingDataCount_WhenFull", 278 pending_data_count_, 0, 100, 100); 279 *defer = did_defer_ = true; 280 } 281 282 return true; 283 } 284 285 void AsyncResourceHandler::OnDataDownloaded( 286 int request_id, int bytes_downloaded) { 287 filter_->Send(new ResourceMsg_DataDownloaded( 288 routing_id_, request_id, bytes_downloaded)); 289 } 290 291 bool AsyncResourceHandler::OnResponseCompleted( 292 int request_id, 293 const net::URLRequestStatus& status, 294 const std::string& security_info) { 295 // If we crash here, figure out what URL the renderer was requesting. 296 // http://crbug.com/107692 297 char url_buf[128]; 298 base::strlcpy(url_buf, request_->url().spec().c_str(), arraysize(url_buf)); 299 base::debug::Alias(url_buf); 300 301 // TODO(gavinp): Remove this CHECK when we figure out the cause of 302 // http://crbug.com/124680 . This check mirrors closely check in 303 // WebURLLoaderImpl::OnCompletedRequest that routes this message to a WebCore 304 // ResourceHandleInternal which asserts on its state and crashes. By crashing 305 // when the message is sent, we should get better crash reports. 306 CHECK(status.status() != net::URLRequestStatus::SUCCESS || 307 sent_received_response_msg_); 308 309 TimeTicks completion_time = TimeTicks::Now(); 310 311 int error_code = status.error(); 312 bool was_ignored_by_handler = 313 ResourceRequestInfoImpl::ForRequest(request_)->WasIgnoredByHandler(); 314 315 DCHECK(status.status() != net::URLRequestStatus::IO_PENDING); 316 // If this check fails, then we're in an inconsistent state because all 317 // requests ignored by the handler should be canceled (which should result in 318 // the ERR_ABORTED error code). 319 DCHECK(!was_ignored_by_handler || error_code == net::ERR_ABORTED); 320 321 // TODO(mkosiba): Fix up cases where we create a URLRequestStatus 322 // with a status() != SUCCESS and an error_code() == net::OK. 323 if (status.status() == net::URLRequestStatus::CANCELED && 324 error_code == net::OK) { 325 error_code = net::ERR_ABORTED; 326 } else if (status.status() == net::URLRequestStatus::FAILED && 327 error_code == net::OK) { 328 error_code = net::ERR_FAILED; 329 } 330 331 filter_->Send(new ResourceMsg_RequestComplete(routing_id_, 332 request_id, 333 error_code, 334 was_ignored_by_handler, 335 security_info, 336 completion_time)); 337 return true; 338 } 339 340 bool AsyncResourceHandler::EnsureResourceBufferIsInitialized() { 341 if (buffer_.get() && buffer_->IsInitialized()) 342 return true; 343 344 if (!has_checked_for_sufficient_resources_) { 345 has_checked_for_sufficient_resources_ = true; 346 if (!rdh_->HasSufficientResourcesForRequest(request_)) { 347 controller()->CancelWithError(net::ERR_INSUFFICIENT_RESOURCES); 348 return false; 349 } 350 } 351 352 buffer_ = new ResourceBuffer(); 353 return buffer_->Initialize(kBufferSize, 354 kMinAllocationSize, 355 kMaxAllocationSize); 356 } 357 358 void AsyncResourceHandler::ResumeIfDeferred() { 359 if (did_defer_) { 360 did_defer_ = false; 361 controller()->Resume(); 362 } 363 } 364 365 } // namespace content 366