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
GetNumericArg(const std::string & name,int * result)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
InitializeResourceBufferConstants()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
CalcUsedPercentage(int bytes_read,int buffer_size)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:
DependentIOBuffer(ResourceBuffer * backing,char * memory)70 DependentIOBuffer(ResourceBuffer* backing, char* memory)
71 : net::WrappedIOBuffer(memory),
72 backing_(backing) {
73 }
74 private:
~DependentIOBuffer()75 virtual ~DependentIOBuffer() {}
76 scoped_refptr<ResourceBuffer> backing_;
77 };
78
AsyncResourceHandler(net::URLRequest * request,ResourceDispatcherHostImpl * rdh)79 AsyncResourceHandler::AsyncResourceHandler(
80 net::URLRequest* request,
81 ResourceDispatcherHostImpl* rdh)
82 : ResourceHandler(request),
83 ResourceMessageDelegate(request),
84 rdh_(rdh),
85 pending_data_count_(0),
86 allocation_size_(0),
87 did_defer_(false),
88 has_checked_for_sufficient_resources_(false),
89 sent_received_response_msg_(false),
90 sent_first_data_msg_(false) {
91 InitializeResourceBufferConstants();
92 }
93
~AsyncResourceHandler()94 AsyncResourceHandler::~AsyncResourceHandler() {
95 if (has_checked_for_sufficient_resources_)
96 rdh_->FinishedWithResourcesForRequest(request());
97 }
98
OnMessageReceived(const IPC::Message & message,bool * message_was_ok)99 bool AsyncResourceHandler::OnMessageReceived(const IPC::Message& message,
100 bool* message_was_ok) {
101 bool handled = true;
102 IPC_BEGIN_MESSAGE_MAP_EX(AsyncResourceHandler, message, *message_was_ok)
103 IPC_MESSAGE_HANDLER(ResourceHostMsg_FollowRedirect, OnFollowRedirect)
104 IPC_MESSAGE_HANDLER(ResourceHostMsg_DataReceived_ACK, OnDataReceivedACK)
105 IPC_MESSAGE_UNHANDLED(handled = false)
106 IPC_END_MESSAGE_MAP_EX()
107 return handled;
108 }
109
OnFollowRedirect(int request_id,bool has_new_first_party_for_cookies,const GURL & new_first_party_for_cookies)110 void AsyncResourceHandler::OnFollowRedirect(
111 int request_id,
112 bool has_new_first_party_for_cookies,
113 const GURL& new_first_party_for_cookies) {
114 if (!request()->status().is_success()) {
115 DVLOG(1) << "OnFollowRedirect for invalid request";
116 return;
117 }
118
119 if (has_new_first_party_for_cookies)
120 request()->set_first_party_for_cookies(new_first_party_for_cookies);
121
122 ResumeIfDeferred();
123 }
124
OnDataReceivedACK(int request_id)125 void AsyncResourceHandler::OnDataReceivedACK(int request_id) {
126 if (pending_data_count_) {
127 --pending_data_count_;
128
129 buffer_->RecycleLeastRecentlyAllocated();
130 if (buffer_->CanAllocate())
131 ResumeIfDeferred();
132 }
133 }
134
OnUploadProgress(int request_id,uint64 position,uint64 size)135 bool AsyncResourceHandler::OnUploadProgress(int request_id,
136 uint64 position,
137 uint64 size) {
138 ResourceMessageFilter* filter = GetFilter();
139 if (!filter)
140 return false;
141 return filter->Send(
142 new ResourceMsg_UploadProgress(request_id, position, size));
143 }
144
OnRequestRedirected(int request_id,const GURL & new_url,ResourceResponse * response,bool * defer)145 bool AsyncResourceHandler::OnRequestRedirected(int request_id,
146 const GURL& new_url,
147 ResourceResponse* response,
148 bool* defer) {
149 const ResourceRequestInfoImpl* info = GetRequestInfo();
150 if (!info->filter())
151 return false;
152
153 *defer = did_defer_ = true;
154 OnDefer();
155
156 if (rdh_->delegate()) {
157 rdh_->delegate()->OnRequestRedirected(
158 new_url, request(), info->GetContext(), response);
159 }
160
161 DevToolsNetLogObserver::PopulateResponseInfo(request(), response);
162 response->head.request_start = request()->creation_time();
163 response->head.response_start = TimeTicks::Now();
164 return info->filter()->Send(new ResourceMsg_ReceivedRedirect(
165 request_id, new_url, response->head));
166 }
167
OnResponseStarted(int request_id,ResourceResponse * response,bool * defer)168 bool AsyncResourceHandler::OnResponseStarted(int request_id,
169 ResourceResponse* response,
170 bool* defer) {
171 // For changes to the main frame, inform the renderer of the new URL's
172 // per-host settings before the request actually commits. This way the
173 // renderer will be able to set these precisely at the time the
174 // request commits, avoiding the possibility of e.g. zooming the old content
175 // or of having to layout the new content twice.
176
177 const ResourceRequestInfoImpl* info = GetRequestInfo();
178 if (!info->filter())
179 return false;
180
181 if (rdh_->delegate()) {
182 rdh_->delegate()->OnResponseStarted(
183 request(), info->GetContext(), response, info->filter());
184 }
185
186 DevToolsNetLogObserver::PopulateResponseInfo(request(), response);
187
188 HostZoomMap* host_zoom_map =
189 GetHostZoomMapForResourceContext(info->GetContext());
190
191 if (info->GetResourceType() == ResourceType::MAIN_FRAME && host_zoom_map) {
192 const GURL& request_url = request()->url();
193 info->filter()->Send(new ViewMsg_SetZoomLevelForLoadingURL(
194 info->GetRouteID(),
195 request_url, host_zoom_map->GetZoomLevelForHostAndScheme(
196 request_url.scheme(),
197 net::GetHostOrSpecFromURL(request_url))));
198 }
199
200 response->head.request_start = request()->creation_time();
201 response->head.response_start = TimeTicks::Now();
202 info->filter()->Send(new ResourceMsg_ReceivedResponse(request_id,
203 response->head));
204 sent_received_response_msg_ = true;
205
206 if (request()->response_info().metadata.get()) {
207 std::vector<char> copy(request()->response_info().metadata->data(),
208 request()->response_info().metadata->data() +
209 request()->response_info().metadata->size());
210 info->filter()->Send(new ResourceMsg_ReceivedCachedMetadata(request_id,
211 copy));
212 }
213
214 return true;
215 }
216
OnWillStart(int request_id,const GURL & url,bool * defer)217 bool AsyncResourceHandler::OnWillStart(int request_id,
218 const GURL& url,
219 bool* defer) {
220 return true;
221 }
222
OnWillRead(int request_id,scoped_refptr<net::IOBuffer> * buf,int * buf_size,int min_size)223 bool AsyncResourceHandler::OnWillRead(int request_id,
224 scoped_refptr<net::IOBuffer>* buf,
225 int* buf_size,
226 int min_size) {
227 DCHECK_EQ(-1, min_size);
228
229 if (!EnsureResourceBufferIsInitialized())
230 return false;
231
232 DCHECK(buffer_->CanAllocate());
233 char* memory = buffer_->Allocate(&allocation_size_);
234 CHECK(memory);
235
236 *buf = new DependentIOBuffer(buffer_.get(), memory);
237 *buf_size = allocation_size_;
238
239 UMA_HISTOGRAM_CUSTOM_COUNTS(
240 "Net.AsyncResourceHandler_SharedIOBuffer_Alloc",
241 *buf_size, 0, kMaxAllocationSize, 100);
242 return true;
243 }
244
OnReadCompleted(int request_id,int bytes_read,bool * defer)245 bool AsyncResourceHandler::OnReadCompleted(int request_id, int bytes_read,
246 bool* defer) {
247 DCHECK_GE(bytes_read, 0);
248
249 if (!bytes_read)
250 return true;
251
252 ResourceMessageFilter* filter = GetFilter();
253 if (!filter)
254 return false;
255
256 buffer_->ShrinkLastAllocation(bytes_read);
257
258 UMA_HISTOGRAM_CUSTOM_COUNTS(
259 "Net.AsyncResourceHandler_SharedIOBuffer_Used",
260 bytes_read, 0, kMaxAllocationSize, 100);
261 UMA_HISTOGRAM_PERCENTAGE(
262 "Net.AsyncResourceHandler_SharedIOBuffer_UsedPercentage",
263 CalcUsedPercentage(bytes_read, allocation_size_));
264
265 if (!sent_first_data_msg_) {
266 base::SharedMemoryHandle handle;
267 int size;
268 if (!buffer_->ShareToProcess(filter->PeerHandle(), &handle, &size))
269 return false;
270 filter->Send(new ResourceMsg_SetDataBuffer(
271 request_id, handle, size, filter->peer_pid()));
272 sent_first_data_msg_ = true;
273 }
274
275 int data_offset = buffer_->GetLastAllocationOffset();
276 int encoded_data_length =
277 DevToolsNetLogObserver::GetAndResetEncodedDataLength(request());
278
279 filter->Send(new ResourceMsg_DataReceived(
280 request_id, data_offset, bytes_read, encoded_data_length));
281 ++pending_data_count_;
282 UMA_HISTOGRAM_CUSTOM_COUNTS(
283 "Net.AsyncResourceHandler_PendingDataCount",
284 pending_data_count_, 0, 100, 100);
285
286 if (!buffer_->CanAllocate()) {
287 UMA_HISTOGRAM_CUSTOM_COUNTS(
288 "Net.AsyncResourceHandler_PendingDataCount_WhenFull",
289 pending_data_count_, 0, 100, 100);
290 *defer = did_defer_ = true;
291 OnDefer();
292 }
293
294 return true;
295 }
296
OnDataDownloaded(int request_id,int bytes_downloaded)297 void AsyncResourceHandler::OnDataDownloaded(
298 int request_id, int bytes_downloaded) {
299 int encoded_data_length =
300 DevToolsNetLogObserver::GetAndResetEncodedDataLength(request());
301
302 ResourceMessageFilter* filter = GetFilter();
303 if (filter) {
304 filter->Send(new ResourceMsg_DataDownloaded(
305 request_id, bytes_downloaded, encoded_data_length));
306 }
307 }
308
OnResponseCompleted(int request_id,const net::URLRequestStatus & status,const std::string & security_info,bool * defer)309 void AsyncResourceHandler::OnResponseCompleted(
310 int request_id,
311 const net::URLRequestStatus& status,
312 const std::string& security_info,
313 bool* defer) {
314 const ResourceRequestInfoImpl* info = GetRequestInfo();
315 if (!info->filter())
316 return;
317
318 // If we crash here, figure out what URL the renderer was requesting.
319 // http://crbug.com/107692
320 char url_buf[128];
321 base::strlcpy(url_buf, request()->url().spec().c_str(), arraysize(url_buf));
322 base::debug::Alias(url_buf);
323
324 // TODO(gavinp): Remove this CHECK when we figure out the cause of
325 // http://crbug.com/124680 . This check mirrors closely check in
326 // WebURLLoaderImpl::OnCompletedRequest that routes this message to a WebCore
327 // ResourceHandleInternal which asserts on its state and crashes. By crashing
328 // when the message is sent, we should get better crash reports.
329 CHECK(status.status() != net::URLRequestStatus::SUCCESS ||
330 sent_received_response_msg_);
331
332 TimeTicks completion_time = TimeTicks::Now();
333
334 int error_code = status.error();
335 bool was_ignored_by_handler = info->WasIgnoredByHandler();
336
337 DCHECK(status.status() != net::URLRequestStatus::IO_PENDING);
338 // If this check fails, then we're in an inconsistent state because all
339 // requests ignored by the handler should be canceled (which should result in
340 // the ERR_ABORTED error code).
341 DCHECK(!was_ignored_by_handler || error_code == net::ERR_ABORTED);
342
343 // TODO(mkosiba): Fix up cases where we create a URLRequestStatus
344 // with a status() != SUCCESS and an error_code() == net::OK.
345 if (status.status() == net::URLRequestStatus::CANCELED &&
346 error_code == net::OK) {
347 error_code = net::ERR_ABORTED;
348 } else if (status.status() == net::URLRequestStatus::FAILED &&
349 error_code == net::OK) {
350 error_code = net::ERR_FAILED;
351 }
352
353 info->filter()->Send(
354 new ResourceMsg_RequestComplete(request_id,
355 error_code,
356 was_ignored_by_handler,
357 security_info,
358 completion_time));
359 }
360
EnsureResourceBufferIsInitialized()361 bool AsyncResourceHandler::EnsureResourceBufferIsInitialized() {
362 if (buffer_.get() && buffer_->IsInitialized())
363 return true;
364
365 if (!has_checked_for_sufficient_resources_) {
366 has_checked_for_sufficient_resources_ = true;
367 if (!rdh_->HasSufficientResourcesForRequest(request())) {
368 controller()->CancelWithError(net::ERR_INSUFFICIENT_RESOURCES);
369 return false;
370 }
371 }
372
373 buffer_ = new ResourceBuffer();
374 return buffer_->Initialize(kBufferSize,
375 kMinAllocationSize,
376 kMaxAllocationSize);
377 }
378
ResumeIfDeferred()379 void AsyncResourceHandler::ResumeIfDeferred() {
380 if (did_defer_) {
381 did_defer_ = false;
382 request()->LogUnblocked();
383 controller()->Resume();
384 }
385 }
386
OnDefer()387 void AsyncResourceHandler::OnDefer() {
388 request()->LogBlockedBy("AsyncResourceHandler");
389 }
390
391 } // namespace content
392