Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1467)

Unified Diff: content/browser/loader/intercepting_resource_handler.cc

Issue 2005273002: Move MimeTypeResourceHandler before ThrottlingResourceHandler (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Fixed issue in ResourceDispatcherHostTests Created 4 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: content/browser/loader/intercepting_resource_handler.cc
diff --git a/content/browser/loader/mime_type_resource_handler.cc b/content/browser/loader/intercepting_resource_handler.cc
similarity index 48%
copy from content/browser/loader/mime_type_resource_handler.cc
copy to content/browser/loader/intercepting_resource_handler.cc
index ab4fca3a8dbdc4780fb66e01878e11c1a5aa31eb..05e3c378d53e1e7cbb224eb64225584a14ac72d4 100644
--- a/content/browser/loader/mime_type_resource_handler.cc
+++ b/content/browser/loader/intercepting_resource_handler.cc
@@ -1,8 +1,8 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright 2016 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/mime_type_resource_handler.h"
+#include "content/browser/loader/intercepting_resource_handler.h"
#include <utility>
#include <vector>
@@ -30,294 +30,90 @@
#include "content/public/common/resource_response.h"
#include "content/public/common/webplugininfo.h"
#include "net/base/io_buffer.h"
-#include "net/base/mime_sniffer.h"
#include "net/base/mime_util.h"
-#include "net/base/net_errors.h"
#include "net/http/http_content_disposition.h"
#include "net/http/http_response_headers.h"
-#include "net/url_request/url_request.h"
namespace content {
-namespace {
-
-const char kAcceptHeader[] = "Accept";
-const char kFrameAcceptHeader[] =
- "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,"
- "*/*;q=0.8";
-const char kStylesheetAcceptHeader[] = "text/css,*/*;q=0.1";
-const char kImageAcceptHeader[] = "image/webp,image/*,*/*;q=0.8";
-const char kDefaultAcceptHeader[] = "*/*";
-
-// Used to write into an existing IOBuffer at a given offset.
-class DependentIOBuffer : public net::WrappedIOBuffer {
- public:
- DependentIOBuffer(net::IOBuffer* buf, int offset)
- : net::WrappedIOBuffer(buf->data() + offset),
- buf_(buf) {
- }
-
- private:
- ~DependentIOBuffer() override {}
-
- scoped_refptr<net::IOBuffer> buf_;
-};
-
-} // namespace
-
-MimeTypeResourceHandler::MimeTypeResourceHandler(
+InterceptingResourceHandler::InterceptingResourceHandler(
std::unique_ptr<ResourceHandler> next_handler,
ResourceDispatcherHostImpl* host,
PluginService* plugin_service,
net::URLRequest* request)
: LayeredResourceHandler(request, std::move(next_handler)),
- state_(STATE_STARTING),
+ state_(State::STARTING),
host_(host),
#if defined(ENABLE_PLUGINS)
plugin_service_(plugin_service),
#endif
- read_buffer_size_(0),
- bytes_read_(0),
+ switched_handler_(false),
must_download_(false),
must_download_is_set_(false),
+ bytes_read_(0),
weak_ptr_factory_(this) {
}
-MimeTypeResourceHandler::~MimeTypeResourceHandler() {
-}
-
-void MimeTypeResourceHandler::SetController(ResourceController* controller) {
- ResourceHandler::SetController(controller);
-
- // Downstream handlers see us as their ResourceController, which allows us to
- // consume part or all of the resource response, and then later replay it to
- // downstream handler.
- DCHECK(next_handler_.get());
- next_handler_->SetController(this);
-}
-
-bool MimeTypeResourceHandler::OnResponseStarted(ResourceResponse* response,
- bool* defer) {
- response_ = response;
+InterceptingResourceHandler::~InterceptingResourceHandler() {}
- // A 304 response should not contain a Content-Type header (RFC 7232 section
- // 4.1). The following code may incorrectly attempt to add a Content-Type to
- // the response, and so must be skipped for 304 responses.
- if (!(response_->head.headers.get() &&
- response_->head.headers->response_code() == 304)) {
- if (ShouldSniffContent()) {
- state_ = STATE_BUFFERING;
- return true;
- }
-
- if (response_->head.mime_type.empty()) {
- // Ugg. The server told us not to sniff the content but didn't give us
- // a mime type. What's a browser to do? Turns out, we're supposed to
- // treat the response as "text/plain". This is the most secure option.
- response_->head.mime_type.assign("text/plain");
- }
-
- // Treat feed types as text/plain.
- if (response_->head.mime_type == "application/rss+xml" ||
- response_->head.mime_type == "application/atom+xml") {
- response_->head.mime_type.assign("text/plain");
- }
+bool InterceptingResourceHandler::OnResponseStarted(ResourceResponse* response,
+ bool* defer) {
+ if (response->head.headers.get() &&
+ response->head.headers->response_code() == 304) {
asanka 2016/06/22 20:26:53 For HTTP(-like) responses, this class does the fol
mmenke 2016/06/22 20:31:18 If this is an <a download> link, but we get a 4xx
asanka 2016/06/23 02:26:17 <a download>s are explicit downloads and don't use
clamy 2016/06/28 16:20:41 I've moved the interception choice case to the Mim
clamy 2016/06/29 13:35:57 It appears that one of teh unit tests is (Forbidde
+ state_ = State::DONE;
+ return next_handler_->OnResponseStarted(response, defer);
}
- state_ = STATE_PROCESSING;
- return ProcessResponse(defer);
-}
-
-bool MimeTypeResourceHandler::OnWillStart(const GURL& url, bool* defer) {
- const char* accept_value = nullptr;
- switch (GetRequestInfo()->GetResourceType()) {
- case RESOURCE_TYPE_MAIN_FRAME:
- case RESOURCE_TYPE_SUB_FRAME:
- accept_value = kFrameAcceptHeader;
- break;
- case RESOURCE_TYPE_STYLESHEET:
- accept_value = kStylesheetAcceptHeader;
- break;
- case RESOURCE_TYPE_IMAGE:
- accept_value = kImageAcceptHeader;
- break;
- case RESOURCE_TYPE_SCRIPT:
- case RESOURCE_TYPE_FONT_RESOURCE:
- case RESOURCE_TYPE_SUB_RESOURCE:
- case RESOURCE_TYPE_OBJECT:
- case RESOURCE_TYPE_MEDIA:
- case RESOURCE_TYPE_WORKER:
- case RESOURCE_TYPE_SHARED_WORKER:
- case RESOURCE_TYPE_PREFETCH:
- case RESOURCE_TYPE_FAVICON:
- case RESOURCE_TYPE_XHR:
- case RESOURCE_TYPE_PING:
- case RESOURCE_TYPE_SERVICE_WORKER:
- case RESOURCE_TYPE_CSP_REPORT:
- case RESOURCE_TYPE_PLUGIN_RESOURCE:
- accept_value = kDefaultAcceptHeader;
- break;
- case RESOURCE_TYPE_LAST_TYPE:
- NOTREACHED();
- break;
- }
+ response_ = response;
- // The false parameter prevents overwriting an existing accept header value,
- // which is needed because JS can manually set an accept header on an XHR.
- request()->SetExtraRequestHeaderByName(kAcceptHeader, accept_value, false);
- return next_handler_->OnWillStart(url, defer);
+ return MakeHandlerChoice(defer);
}
-bool MimeTypeResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
- int* buf_size,
- int min_size) {
- if (state_ == STATE_STREAMING)
+bool InterceptingResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
+ int* buf_size,
+ int min_size) {
+ if (state_ == State::DONE)
return next_handler_->OnWillRead(buf, buf_size, min_size);
+ DCHECK_EQ(State::STARTING, state_);
DCHECK_EQ(-1, min_size);
- if (read_buffer_.get()) {
- CHECK_LT(bytes_read_, read_buffer_size_);
- *buf = new DependentIOBuffer(read_buffer_.get(), bytes_read_);
- *buf_size = read_buffer_size_ - bytes_read_;
- } else {
- if (!next_handler_->OnWillRead(buf, buf_size, min_size))
- return false;
+ if (!next_handler_->OnWillRead(buf, buf_size, min_size))
+ return false;
- read_buffer_ = *buf;
- read_buffer_size_ = *buf_size;
- DCHECK_GE(read_buffer_size_, net::kMaxBytesToSniff * 2);
- }
+ read_buffer_ = *buf;
return true;
}
-bool MimeTypeResourceHandler::OnReadCompleted(int bytes_read, bool* defer) {
- if (state_ == STATE_STREAMING)
+bool InterceptingResourceHandler::OnReadCompleted(int bytes_read, bool* defer) {
+ if (state_ == State::DONE)
return next_handler_->OnReadCompleted(bytes_read, defer);
- DCHECK_EQ(state_, STATE_BUFFERING);
+ DCHECK_EQ(State::WAITING_FOR_BUFFER_COPY, state_);
bytes_read_ += bytes_read;
+ if (!CopyReadBufferToNextHandler())
+ return false;
- if (!DetermineMimeType() && (bytes_read > 0))
- return true; // Needs more data, so keep buffering.
-
- state_ = STATE_PROCESSING;
- return ProcessResponse(defer);
-}
-
-void MimeTypeResourceHandler::OnResponseCompleted(
- const net::URLRequestStatus& status,
- const std::string& security_info,
- bool* defer) {
- // Upon completion, act like a pass-through handler in case the downstream
- // handler defers OnResponseCompleted.
- state_ = STATE_STREAMING;
-
- next_handler_->OnResponseCompleted(status, security_info, defer);
-}
-
-void MimeTypeResourceHandler::Resume() {
- switch (state_) {
- case STATE_BUFFERING:
- case STATE_PROCESSING:
- NOTREACHED();
- break;
- case STATE_REPLAYING:
- base::ThreadTaskRunnerHandle::Get()->PostTask(
- FROM_HERE,
- base::Bind(&MimeTypeResourceHandler::CallReplayReadCompleted,
- weak_ptr_factory_.GetWeakPtr()));
- break;
- case STATE_STARTING:
- case STATE_STREAMING:
- controller()->Resume();
- break;
- }
-}
-
-void MimeTypeResourceHandler::Cancel() {
- controller()->Cancel();
-}
-
-void MimeTypeResourceHandler::CancelAndIgnore() {
- controller()->CancelAndIgnore();
-}
-
-void MimeTypeResourceHandler::CancelWithError(int error_code) {
- controller()->CancelWithError(error_code);
+ return next_handler_->OnReadCompleted(bytes_read, defer);
}
-bool MimeTypeResourceHandler::ProcessResponse(bool* defer) {
- DCHECK_EQ(STATE_PROCESSING, state_);
-
- // TODO(darin): Stop special-casing 304 responses.
- if (!(response_->head.headers.get() &&
- response_->head.headers->response_code() == 304)) {
- if (!SelectNextHandler(defer))
- return false;
- if (*defer)
- return true;
- }
-
- state_ = STATE_REPLAYING;
-
- if (!next_handler_->OnResponseStarted(response_.get(), defer))
+bool InterceptingResourceHandler::MakeHandlerChoice(bool* defer) {
+ if (!SelectNextHandler(defer))
return false;
- if (!read_buffer_.get()) {
- state_ = STATE_STREAMING;
+ if (*defer)
return true;
- }
- if (!*defer)
- return ReplayReadCompleted(defer);
+ if (!next_handler_->OnResponseStarted(response_.get(), defer))
+ return false;
+ state_ = read_buffer_ && switched_handler_ ? State::WAITING_FOR_BUFFER_COPY
+ : State::DONE;
return true;
}
-bool MimeTypeResourceHandler::ShouldSniffContent() {
- const std::string& mime_type = response_->head.mime_type;
-
- std::string content_type_options;
- request()->GetResponseHeaderByName("x-content-type-options",
- &content_type_options);
-
- bool sniffing_blocked =
- base::LowerCaseEqualsASCII(content_type_options, "nosniff");
- bool we_would_like_to_sniff =
- net::ShouldSniffMimeType(request()->url(), mime_type);
-
- if (!sniffing_blocked && we_would_like_to_sniff) {
- // We're going to look at the data before deciding what the content type
- // is. That means we need to delay sending the ResponseStarted message
- // over the IPC channel.
- VLOG(1) << "To buffer: " << request()->url().spec();
- return true;
- }
-
- return false;
-}
-
-bool MimeTypeResourceHandler::DetermineMimeType() {
- DCHECK_EQ(STATE_BUFFERING, state_);
-
- const std::string& type_hint = response_->head.mime_type;
-
- std::string new_type;
- bool made_final_decision =
- net::SniffMimeType(read_buffer_->data(), bytes_read_, request()->url(),
- type_hint, &new_type);
-
- // SniffMimeType() returns false if there is not enough data to determine
- // the mime type. However, even if it returns false, it returns a new type
- // that is probably better than the current one.
- response_->head.mime_type.assign(new_type);
-
- return made_final_decision;
-}
-
-bool MimeTypeResourceHandler::SelectPluginHandler(bool* defer,
- bool* handled_by_plugin) {
+bool InterceptingResourceHandler::SelectPluginHandler(bool* defer,
+ bool* handled_by_plugin) {
*handled_by_plugin = false;
#if defined(ENABLE_PLUGINS)
ResourceRequestInfoImpl* info = GetRequestInfo();
@@ -330,11 +126,13 @@ bool MimeTypeResourceHandler::SelectPluginHandler(bool* defer,
&stale, &plugin, NULL);
if (stale) {
+ state_ = State::WAITING_FOR_PLUGINS;
+
// Refresh the plugins asynchronously.
plugin_service_->GetPlugins(
- base::Bind(&MimeTypeResourceHandler::OnPluginsLoaded,
+ base::Bind(&InterceptingResourceHandler::OnPluginsLoaded,
weak_ptr_factory_.GetWeakPtr()));
- request()->LogBlockedBy("MimeTypeResourceHandler");
+ request()->LogBlockedBy("InterceptingResourceHandler");
*defer = true;
return true;
}
@@ -359,7 +157,7 @@ bool MimeTypeResourceHandler::SelectPluginHandler(bool* defer,
return true;
}
-bool MimeTypeResourceHandler::SelectNextHandler(bool* defer) {
+bool InterceptingResourceHandler::SelectNextHandler(bool* defer) {
DCHECK(!response_->head.mime_type.empty());
ResourceRequestInfoImpl* info = GetRequestInfo();
@@ -416,7 +214,7 @@ bool MimeTypeResourceHandler::SelectNextHandler(bool* defer) {
return UseAlternateNextHandler(std::move(handler), std::string());
}
-bool MimeTypeResourceHandler::UseAlternateNextHandler(
+bool InterceptingResourceHandler::UseAlternateNextHandler(
std::unique_ptr<ResourceHandler> new_handler,
const std::string& payload_for_old_handler) {
if (response_->head.headers.get() && // Can be NULL if FTP.
@@ -447,13 +245,10 @@ bool MimeTypeResourceHandler::UseAlternateNextHandler(
} else {
scoped_refptr<net::IOBuffer> buf;
int size = 0;
-
next_handler_->OnWillRead(&buf, &size, -1);
asanka 2016/06/22 20:26:53 Is this correct? It seems that the old handler cou
clamy 2016/06/28 16:20:41 I'm now doing a OnReadCompleted of size 0 so that
CHECK_GE(size, static_cast<int>(payload_for_old_handler.length()));
-
memcpy(buf->data(), payload_for_old_handler.c_str(),
payload_for_old_handler.length());
-
next_handler_->OnReadCompleted(payload_for_old_handler.length(),
&defer_ignored);
DCHECK(!defer_ignored);
@@ -466,36 +261,14 @@ bool MimeTypeResourceHandler::UseAlternateNextHandler(
// This is handled entirely within the new ResourceHandler, so just reset the
// original ResourceHandler.
next_handler_ = std::move(new_handler);
- next_handler_->SetController(this);
-
- return CopyReadBufferToNextHandler();
-}
-
-bool MimeTypeResourceHandler::ReplayReadCompleted(bool* defer) {
- DCHECK(read_buffer_.get());
-
- bool result = next_handler_->OnReadCompleted(bytes_read_, defer);
-
- read_buffer_ = NULL;
- read_buffer_size_ = 0;
- bytes_read_ = 0;
+ next_handler_->SetController(controller());
- state_ = STATE_STREAMING;
+ switched_handler_ = true;
- return result;
-}
-
-void MimeTypeResourceHandler::CallReplayReadCompleted() {
- bool defer = false;
- if (!ReplayReadCompleted(&defer)) {
- controller()->Cancel();
- } else if (!defer) {
- state_ = STATE_STREAMING;
- controller()->Resume();
- }
+ return true;
}
-bool MimeTypeResourceHandler::MustDownload() {
+bool InterceptingResourceHandler::MustDownload() {
if (must_download_is_set_)
return must_download_;
@@ -517,10 +290,19 @@ bool MimeTypeResourceHandler::MustDownload() {
return must_download_;
}
-bool MimeTypeResourceHandler::CopyReadBufferToNextHandler() {
- if (!read_buffer_.get())
- return true;
+void InterceptingResourceHandler::OnPluginsLoaded(
+ const std::vector<WebPluginInfo>& plugins) {
+ request()->LogUnblocked();
+ bool defer = false;
+ if (!MakeHandlerChoice(&defer)) {
+ controller()->Cancel();
+ } else if (!defer) {
+ controller()->Resume();
+ }
+}
+bool InterceptingResourceHandler::CopyReadBufferToNextHandler() {
+ DCHECK(read_buffer_.get());
scoped_refptr<net::IOBuffer> buf;
int buf_len = 0;
if (!next_handler_->OnWillRead(&buf, &buf_len, bytes_read_))
@@ -528,18 +310,8 @@ bool MimeTypeResourceHandler::CopyReadBufferToNextHandler() {
CHECK((buf_len >= bytes_read_) && (bytes_read_ >= 0));
memcpy(buf->data(), read_buffer_->data(), bytes_read_);
+ state_ = State::DONE;
return true;
}
-void MimeTypeResourceHandler::OnPluginsLoaded(
- const std::vector<WebPluginInfo>& plugins) {
- request()->LogUnblocked();
- bool defer = false;
- if (!ProcessResponse(&defer)) {
- controller()->Cancel();
- } else if (!defer) {
- controller()->Resume();
- }
-}
-
} // namespace content

Powered by Google App Engine
This is Rietveld 408576698