Index: content/browser/loader/detached_resource_handler.cc |
diff --git a/content/browser/loader/detached_resource_handler.cc b/content/browser/loader/detached_resource_handler.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..03592e6ffdf34c5ae65f5962787d61eeefd81e40 |
--- /dev/null |
+++ b/content/browser/loader/detached_resource_handler.cc |
@@ -0,0 +1,149 @@ |
+// Copyright (c) 2013 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/detached_resource_handler.h" |
+ |
+#include <algorithm> |
+#include <vector> |
+ |
+#include "base/debug/alias.h" |
+#include "base/strings/string_util.h" |
+#include "content/browser/devtools/devtools_netlog_observer.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/public/browser/resource_dispatcher_host_delegate.h" |
+#include "net/base/io_buffer.h" |
+#include "net/base/net_errors.h" |
+#include "net/url_request/url_request.h" |
+ |
+using base::TimeTicks; |
+ |
+namespace content { |
+ |
+namespace { |
+ |
+static const int kReadBufSize = 1024 * 32; |
+ |
+} // namespace |
+ |
+ |
+DetachedResourceHandler::DetachedResourceHandler( |
+ net::URLRequest* request, ResourceDispatcherHostImpl* rdh) |
+ : request_(request), rdh_(rdh) {} |
+ |
+DetachedResourceHandler::~DetachedResourceHandler() {} |
+ |
+bool DetachedResourceHandler::OnResponseCompleted( |
+ int request_id, const net::URLRequestStatus& status, |
+ const std::string& security_info) { |
+ const ResourceRequestInfoImpl* info = |
+ ResourceRequestInfoImpl::ForRequest(request_); |
+ |
+ if (!info->filter()) |
+ return true; |
+ |
+ TimeTicks completion_time = TimeTicks::Now(); |
+ |
+ int error_code = status.error(); |
+ |
+ bool was_ignored_by_handler = info->WasIgnoredByHandler(); |
+ |
+ // If this check fails, then we're in an inconsistent state because all |
+ // requests ignored by the handler should be canceled (which should result in |
+ // the ERR_ABORTED error code). |
+ DCHECK(!was_ignored_by_handler || error_code == net::ERR_ABORTED); |
+ |
+ // TODO(mkosiba): Fix up cases where we create a URLRequestStatus |
+ // with a status() != SUCCESS and an error_code() == net::OK. |
+ if (status.status() == net::URLRequestStatus::CANCELED && |
+ error_code == net::OK) { |
+ error_code = net::ERR_ABORTED; |
+ } else if (status.status() == net::URLRequestStatus::FAILED && |
+ error_code == net::OK) { |
+ error_code = net::ERR_FAILED; |
+ } |
+ |
+ info->filter()->Send(new ResourceMsg_RequestComplete( |
+ request_id, error_code, was_ignored_by_handler, security_info, |
+ completion_time)); |
+ return true; |
+} |
+ |
+bool DetachedResourceHandler::OnUploadProgress(int request_id, uint64 position, |
+ uint64 size) { |
+ const ResourceRequestInfoImpl* info = |
+ ResourceRequestInfoImpl::ForRequest(request_); |
+ if (!info->filter()) |
+ return true; |
+ info->filter()->Send( |
+ new ResourceMsg_UploadProgress(request_id, position, size)); |
+ return true; |
+} |
+ |
+bool DetachedResourceHandler::OnResponseStarted(int request_id, |
+ ResourceResponse* response, |
+ bool* defer) { |
+ const ResourceRequestInfoImpl* info = |
+ ResourceRequestInfoImpl::ForRequest(request_); |
+ |
+ if (!info->filter()) |
+ return true; |
+ |
+ if (rdh_->delegate()) { |
+ rdh_->delegate()->OnResponseStarted(request_, info->GetContext(), response, |
+ info->filter()); |
+ } |
+ |
+ DevToolsNetLogObserver::PopulateResponseInfo(request_, response); |
+ |
+ response->head.request_start = request_->creation_time(); |
+ response->head.response_start = TimeTicks::Now(); |
+ info->filter()->Send( |
+ new ResourceMsg_ReceivedResponse(request_id, response->head)); |
+ |
+ 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(request_id, copy)); |
+ } |
+ |
+ return true; |
+} |
+ |
+bool DetachedResourceHandler::OnWillStart(int request_id, const GURL& url, |
+ bool* defer) { |
+ return true; |
+} |
+ |
+bool DetachedResourceHandler::OnWillRead(int request_id, net::IOBuffer** buf, |
+ int* buf_size, int min_size) { |
+ // Give the loader something to write to, though it's not going to be read. |
+ if (!read_buffer_) |
+ read_buffer_ = new net::IOBuffer(kReadBufSize); |
+ |
+ *buf = read_buffer_.get(); |
+ *buf_size = kReadBufSize; |
+ return true; |
+} |
+ |
+bool DetachedResourceHandler::OnReadCompleted(int request_id, int bytes_read, |
+ bool* defer) { |
+ return true; |
+} |
+ |
+bool DetachedResourceHandler::OnRequestRedirected(int request_id, |
+ const GURL& new_url, |
+ ResourceResponse* response, |
+ bool* defer) { |
+ return true; |
+} |
+ |
+void DetachedResourceHandler::OnDataDownloaded(int request_id, |
+ int bytes_downloaded) {} |
+ |
+} // namespace content |