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

Unified Diff: content/browser/renderer_host/buffered_resource_handler.cc

Issue 11414299: Add content/browser/loader/ for resource loading related classes. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src/
Patch Set: Created 8 years 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/renderer_host/buffered_resource_handler.cc
===================================================================
--- content/browser/renderer_host/buffered_resource_handler.cc (revision 171168)
+++ content/browser/renderer_host/buffered_resource_handler.cc (working copy)
@@ -1,462 +0,0 @@
-// Copyright (c) 2012 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/renderer_host/buffered_resource_handler.h"
-
-#include <vector>
-
-#include "base/bind.h"
-#include "base/logging.h"
-#include "base/metrics/histogram.h"
-#include "base/string_util.h"
-#include "content/browser/download/download_resource_handler.h"
-#include "content/browser/download/download_stats.h"
-#include "content/browser/plugin_service_impl.h"
-#include "content/browser/renderer_host/resource_dispatcher_host_impl.h"
-#include "content/browser/renderer_host/resource_request_info_impl.h"
-#include "content/browser/renderer_host/x509_user_cert_resource_handler.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/browser/content_browser_client.h"
-#include "content/public/browser/download_save_info.h"
-#include "content/public/browser/resource_context.h"
-#include "content/public/browser/resource_dispatcher_host_delegate.h"
-#include "content/public/common/resource_response.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 "webkit/plugins/webplugininfo.h"
-
-namespace content {
-
-namespace {
-
-void RecordSnifferMetrics(bool sniffing_blocked,
- bool we_would_like_to_sniff,
- const std::string& mime_type) {
- static base::Histogram* nosniff_usage(NULL);
- if (!nosniff_usage)
- nosniff_usage = base::BooleanHistogram::FactoryGet(
- "nosniff.usage", base::Histogram::kUmaTargetedHistogramFlag);
- nosniff_usage->AddBoolean(sniffing_blocked);
-
- if (sniffing_blocked) {
- static base::Histogram* nosniff_otherwise(NULL);
- if (!nosniff_otherwise)
- nosniff_otherwise = base::BooleanHistogram::FactoryGet(
- "nosniff.otherwise", base::Histogram::kUmaTargetedHistogramFlag);
- nosniff_otherwise->AddBoolean(we_would_like_to_sniff);
-
- static base::Histogram* nosniff_empty_mime_type(NULL);
- if (!nosniff_empty_mime_type)
- nosniff_empty_mime_type = base::BooleanHistogram::FactoryGet(
- "nosniff.empty_mime_type",
- base::Histogram::kUmaTargetedHistogramFlag);
- nosniff_empty_mime_type->AddBoolean(mime_type.empty());
- }
-}
-
-// 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() {}
-
- scoped_refptr<net::IOBuffer> buf_;
-};
-
-} // namespace
-
-BufferedResourceHandler::BufferedResourceHandler(
- scoped_ptr<ResourceHandler> next_handler,
- ResourceDispatcherHostImpl* host,
- net::URLRequest* request)
- : LayeredResourceHandler(next_handler.Pass()),
- state_(STATE_STARTING),
- host_(host),
- request_(request),
- read_buffer_size_(0),
- bytes_read_(0),
- must_download_(false),
- must_download_is_set_(false),
- weak_ptr_factory_(this) {
-}
-
-BufferedResourceHandler::~BufferedResourceHandler() {
-}
-
-void BufferedResourceHandler::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 BufferedResourceHandler::OnResponseStarted(
- int request_id,
- ResourceResponse* response,
- bool* defer) {
- response_ = response;
-
- // TODO(darin): It is very odd to special-case 304 responses at this level.
- // We do so only because the code always has, see r24977 and r29355. The
- // fact that 204 is no longer special-cased this way suggests that 304 need
- // not be special-cased either.
- //
- // The network stack only forwards 304 responses that were not received in
- // response to a conditional request (i.e., If-Modified-Since). Other 304
- // responses end up being translated to 200 or whatever the cached response
- // code happens to be. It should be very rare to see a 304 at this level.
-
- if (!(response_->head.headers &&
- 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");
- }
- }
-
- state_ = STATE_PROCESSING;
- return ProcessResponse(defer);
-}
-
-// We'll let the original event handler provide a buffer, and reuse it for
-// subsequent reads until we're done buffering.
-bool BufferedResourceHandler::OnWillRead(int request_id, net::IOBuffer** buf,
- int* buf_size, int min_size) {
- if (state_ == STATE_STREAMING)
- return next_handler_->OnWillRead(request_id, buf, buf_size, min_size);
-
- DCHECK_EQ(-1, min_size);
-
- if (read_buffer_) {
- CHECK_LT(bytes_read_, read_buffer_size_);
- *buf = new DependentIOBuffer(read_buffer_, bytes_read_);
- *buf_size = read_buffer_size_ - bytes_read_;
- } else {
- if (!next_handler_->OnWillRead(request_id, buf, buf_size, min_size))
- return false;
-
- read_buffer_ = *buf;
- read_buffer_size_ = *buf_size;
- DCHECK_GE(read_buffer_size_, net::kMaxBytesToSniff * 2);
- }
- return true;
-}
-
-bool BufferedResourceHandler::OnReadCompleted(int request_id, int bytes_read,
- bool* defer) {
- if (state_ == STATE_STREAMING)
- return next_handler_->OnReadCompleted(request_id, bytes_read, defer);
-
- DCHECK_EQ(state_, STATE_BUFFERING);
- bytes_read_ += bytes_read;
-
- if (!DetermineMimeType() && (bytes_read > 0))
- return true; // Needs more data, so keep buffering.
-
- state_ = STATE_PROCESSING;
- return ProcessResponse(defer);
-}
-
-bool BufferedResourceHandler::OnResponseCompleted(
- int request_id,
- const net::URLRequestStatus& status,
- const std::string& security_info) {
- // Upon completion, act like a pass-through handler in case the downstream
- // handler defers OnResponseCompleted.
- state_ = STATE_STREAMING;
-
- return next_handler_->OnResponseCompleted(request_id, status, security_info);
-}
-
-void BufferedResourceHandler::Resume() {
- switch (state_) {
- case STATE_BUFFERING:
- case STATE_PROCESSING:
- NOTREACHED();
- break;
- case STATE_REPLAYING:
- MessageLoop::current()->PostTask(
- FROM_HERE,
- base::Bind(&BufferedResourceHandler::CallReplayReadCompleted,
- weak_ptr_factory_.GetWeakPtr()));
- break;
- case STATE_STARTING:
- case STATE_STREAMING:
- controller()->Resume();
- break;
- }
-}
-
-void BufferedResourceHandler::Cancel() {
- controller()->Cancel();
-}
-
-void BufferedResourceHandler::CancelAndIgnore() {
- controller()->CancelAndIgnore();
-}
-
-void BufferedResourceHandler::CancelWithError(int error_code) {
- controller()->CancelWithError(error_code);
-}
-
-bool BufferedResourceHandler::ProcessResponse(bool* defer) {
- DCHECK_EQ(STATE_PROCESSING, state_);
-
- // TODO(darin): Stop special-casing 304 responses.
- if (!(response_->head.headers &&
- response_->head.headers->response_code() == 304)) {
- if (!SelectNextHandler(defer))
- return false;
- if (*defer)
- return true;
- }
-
- state_ = STATE_REPLAYING;
-
- int request_id = ResourceRequestInfo::ForRequest(request_)->GetRequestID();
- if (!next_handler_->OnResponseStarted(request_id, response_, defer))
- return false;
-
- if (!read_buffer_) {
- state_ = STATE_STREAMING;
- return true;
- }
-
- if (!*defer)
- return ReplayReadCompleted(defer);
-
- return true;
-}
-
-bool BufferedResourceHandler::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 =
- LowerCaseEqualsASCII(content_type_options, "nosniff");
- bool we_would_like_to_sniff =
- net::ShouldSniffMimeType(request_->url(), mime_type);
-
- RecordSnifferMetrics(sniffing_blocked, we_would_like_to_sniff, 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 BufferedResourceHandler::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 BufferedResourceHandler::SelectNextHandler(bool* defer) {
- DCHECK(!response_->head.mime_type.empty());
-
- ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(request_);
- const std::string& mime_type = response_->head.mime_type;
-
- if (mime_type == "application/x-x509-user-cert") {
- // Install X509 handler.
- scoped_ptr<ResourceHandler> handler(
- new X509UserCertResourceHandler(request_,
- info->GetChildID(),
- info->GetRouteID()));
- return UseAlternateNextHandler(handler.Pass());
- }
-
- if (!info->allow_download())
- return true;
-
- if (!MustDownload()) {
- if (net::IsSupportedMimeType(mime_type))
- return true;
-
- bool stale;
- bool has_plugin = HasSupportingPlugin(&stale);
- if (stale) {
- // Refresh the plugins asynchronously.
- PluginServiceImpl::GetInstance()->GetPlugins(
- base::Bind(&BufferedResourceHandler::OnPluginsLoaded,
- weak_ptr_factory_.GetWeakPtr()));
- *defer = true;
- return true;
- }
- if (has_plugin)
- return true;
- }
-
- // Install download handler
- info->set_is_download(true);
- scoped_ptr<ResourceHandler> handler(
- host_->CreateResourceHandlerForDownload(
- request_,
- true, // is_content_initiated
- scoped_ptr<DownloadSaveInfo>(new DownloadSaveInfo()),
- DownloadResourceHandler::OnStartedCallback()));
- return UseAlternateNextHandler(handler.Pass());
-}
-
-bool BufferedResourceHandler::UseAlternateNextHandler(
- scoped_ptr<ResourceHandler> new_handler) {
- if (response_->head.headers && // Can be NULL if FTP.
- response_->head.headers->response_code() / 100 != 2) {
- // The response code indicates that this is an error page, but we don't
- // know how to display the content. We follow Firefox here and show our
- // own error page instead of triggering a download.
- // TODO(abarth): We should abstract the response_code test, but this kind
- // of check is scattered throughout our codebase.
- request_->CancelWithError(net::ERR_FILE_NOT_FOUND);
- return false;
- }
-
- int request_id = ResourceRequestInfo::ForRequest(request_)->GetRequestID();
-
- // Inform the original ResourceHandler that this will be handled entirely by
- // the new ResourceHandler.
- // TODO(darin): We should probably check the return values of these.
- bool defer_ignored = false;
- next_handler_->OnResponseStarted(request_id, response_, &defer_ignored);
- DCHECK(!defer_ignored);
- net::URLRequestStatus status(net::URLRequestStatus::CANCELED,
- net::ERR_ABORTED);
- next_handler_->OnResponseCompleted(request_id, status, std::string());
-
- // This is handled entirely within the new ResourceHandler, so just reset the
- // original ResourceHandler.
- next_handler_ = new_handler.Pass();
- next_handler_->SetController(this);
-
- return CopyReadBufferToNextHandler(request_id);
-}
-
-bool BufferedResourceHandler::ReplayReadCompleted(bool* defer) {
- DCHECK(read_buffer_);
-
- int request_id = ResourceRequestInfo::ForRequest(request_)->GetRequestID();
- bool result = next_handler_->OnReadCompleted(request_id, bytes_read_, defer);
-
- read_buffer_ = NULL;
- read_buffer_size_ = 0;
- bytes_read_ = 0;
-
- state_ = STATE_STREAMING;
-
- return result;
-}
-
-void BufferedResourceHandler::CallReplayReadCompleted() {
- bool defer = false;
- if (!ReplayReadCompleted(&defer)) {
- controller()->Cancel();
- } else if (!defer) {
- state_ = STATE_STREAMING;
- controller()->Resume();
- }
-}
-
-bool BufferedResourceHandler::MustDownload() {
- if (must_download_is_set_)
- return must_download_;
-
- must_download_is_set_ = true;
-
- std::string disposition;
- request_->GetResponseHeaderByName("content-disposition", &disposition);
- if (!disposition.empty() &&
- net::HttpContentDisposition(disposition, std::string()).is_attachment()) {
- must_download_ = true;
- } else if (host_->delegate() &&
- host_->delegate()->ShouldForceDownloadResource(
- request_->url(), response_->head.mime_type)) {
- must_download_ = true;
- } else {
- must_download_ = false;
- }
-
- return must_download_;
-}
-
-bool BufferedResourceHandler::HasSupportingPlugin(bool* stale) {
- ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(request_);
-
- bool allow_wildcard = false;
- webkit::WebPluginInfo plugin;
- return PluginServiceImpl::GetInstance()->GetPluginInfo(
- info->GetChildID(), info->GetRouteID(), info->GetContext(),
- request_->url(), GURL(), response_->head.mime_type, allow_wildcard,
- stale, &plugin, NULL);
-}
-
-bool BufferedResourceHandler::CopyReadBufferToNextHandler(int request_id) {
- if (!bytes_read_)
- return true;
-
- net::IOBuffer* buf = NULL;
- int buf_len = 0;
- if (!next_handler_->OnWillRead(request_id, &buf, &buf_len, bytes_read_))
- return false;
-
- CHECK((buf_len >= bytes_read_) && (bytes_read_ >= 0));
- memcpy(buf->data(), read_buffer_->data(), bytes_read_);
- return true;
-}
-
-void BufferedResourceHandler::OnPluginsLoaded(
- const std::vector<webkit::WebPluginInfo>& plugins) {
- bool defer = false;
- if (!ProcessResponse(&defer)) {
- controller()->Cancel();
- } else if (!defer) {
- controller()->Resume();
- }
-}
-
-} // namespace content
« no previous file with comments | « content/browser/renderer_host/buffered_resource_handler.h ('k') | content/browser/renderer_host/cross_site_resource_handler.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698