content/browser/loader/buffered_resource_handler.cc

   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/buffered_resource_handler.h"
   6
   7 #include <vector>
   8
   9 #include "base/bind.h"
  10 #include "base/logging.h"
  11 #include "base/metrics/histogram.h"
  12 #include "base/strings/string_util.h"
  13 #include "content/browser/download/download_resource_handler.h"
  14 #include "content/browser/download/download_stats.h"
  15 #include "content/browser/loader/certificate_resource_handler.h"
  16 #include "content/browser/loader/resource_dispatcher_host_impl.h"
  17 #include "content/browser/loader/resource_request_info_impl.h"
  18 #include "content/browser/loader/stream_resource_handler.h"
  19 #include "content/browser/plugin_service_impl.h"
  20 #include "content/public/browser/content_browser_client.h"
  21 #include "content/public/browser/download_item.h"
  22 #include "content/public/browser/download_save_info.h"
  23 #include "content/public/browser/download_url_parameters.h"
  24 #include "content/public/browser/resource_context.h"
  25 #include "content/public/browser/resource_dispatcher_host_delegate.h"
  26 #include "content/public/common/resource_response.h"
  27 #include "content/public/common/webplugininfo.h"
  28 #include "net/base/io_buffer.h"
  29 #include "net/base/mime_sniffer.h"
  30 #include "net/base/mime_util.h"
  31 #include "net/base/net_errors.h"
  32 #include "net/http/http_content_disposition.h"
  33 #include "net/http/http_response_headers.h"
  34
  35 namespace content {
  36
  37 namespace {
  38
  39 void RecordSnifferMetrics(bool sniffing_blocked,
  40                           bool we_would_like_to_sniff,
  41                           const std::string& mime_type) {
  42   static base::HistogramBase* nosniff_usage(NULL);
  43   if (!nosniff_usage)
  44     nosniff_usage = base::BooleanHistogram::FactoryGet(
  45         "nosniff.usage", base::HistogramBase::kUmaTargetedHistogramFlag);
  46   nosniff_usage->AddBoolean(sniffing_blocked);
  47
  48   if (sniffing_blocked) {
  49     static base::HistogramBase* nosniff_otherwise(NULL);
  50     if (!nosniff_otherwise)
  51       nosniff_otherwise = base::BooleanHistogram::FactoryGet(
  52           "nosniff.otherwise", base::HistogramBase::kUmaTargetedHistogramFlag);
  53     nosniff_otherwise->AddBoolean(we_would_like_to_sniff);
  54
  55     static base::HistogramBase* nosniff_empty_mime_type(NULL);
  56     if (!nosniff_empty_mime_type)
  57       nosniff_empty_mime_type = base::BooleanHistogram::FactoryGet(
  58           "nosniff.empty_mime_type",
  59           base::HistogramBase::kUmaTargetedHistogramFlag);
  60     nosniff_empty_mime_type->AddBoolean(mime_type.empty());
  61   }
  62 }
  63
  64 // Used to write into an existing IOBuffer at a given offset.
  65 class DependentIOBuffer : public net::WrappedIOBuffer {
  66  public:
  67   DependentIOBuffer(net::IOBuffer* buf, int offset)
  68       : net::WrappedIOBuffer(buf->data() + offset),
  69         buf_(buf) {
  70   }
  71
  72  private:
  73   virtual ~DependentIOBuffer() {}
  74
  75   scoped_refptr<net::IOBuffer> buf_;
  76 };
  77
  78 }  // namespace
  79
  80 BufferedResourceHandler::BufferedResourceHandler(
  81     scoped_ptr<ResourceHandler> next_handler,
  82     ResourceDispatcherHostImpl* host,
  83     net::URLRequest* request)
  84     : LayeredResourceHandler(request, next_handler.Pass()),
  85       state_(STATE_STARTING),
  86       host_(host),
  87       read_buffer_size_(0),
  88       bytes_read_(0),
  89       must_download_(false),
  90       must_download_is_set_(false),
  91       weak_ptr_factory_(this) {
  92 }
  93
  94 BufferedResourceHandler::~BufferedResourceHandler() {
  95 }
  96
  97 void BufferedResourceHandler::SetController(ResourceController* controller) {
  98   ResourceHandler::SetController(controller);
  99
 100   // Downstream handlers see us as their ResourceController, which allows us to
 101   // consume part or all of the resource response, and then later replay it to
 102   // downstream handler.
 103   DCHECK(next_handler_.get());
 104   next_handler_->SetController(this);
 105 }
 106
 107 bool BufferedResourceHandler::OnResponseStarted(ResourceResponse* response,
 108                                                 bool* defer) {
 109   response_ = response;
 110
 111   // TODO(darin): It is very odd to special-case 304 responses at this level.
 112   // We do so only because the code always has, see r24977 and r29355.  The
 113   // fact that 204 is no longer special-cased this way suggests that 304 need
 114   // not be special-cased either.
 115   //
 116   // The network stack only forwards 304 responses that were not received in
 117   // response to a conditional request (i.e., If-Modified-Since).  Other 304
 118   // responses end up being translated to 200 or whatever the cached response
 119   // code happens to be.  It should be very rare to see a 304 at this level.
 120
 121   if (!(response_->head.headers.get() &&
 122         response_->head.headers->response_code() == 304)) {
 123     if (ShouldSniffContent()) {
 124       state_ = STATE_BUFFERING;
 125       return true;
 126     }
 127
 128     if (response_->head.mime_type.empty()) {
 129       // Ugg.  The server told us not to sniff the content but didn't give us
 130       // a mime type.  What's a browser to do?  Turns out, we're supposed to
 131       // treat the response as "text/plain".  This is the most secure option.
 132       response_->head.mime_type.assign("text/plain");
 133     }
 134
 135     // Treat feed types as text/plain.
 136     if (response_->head.mime_type == "application/rss+xml" ||
 137         response_->head.mime_type == "application/atom+xml") {
 138       response_->head.mime_type.assign("text/plain");
 139     }
 140   }
 141
 142   state_ = STATE_PROCESSING;
 143   return ProcessResponse(defer);
 144 }
 145
 146 // We'll let the original event handler provide a buffer, and reuse it for
 147 // subsequent reads until we're done buffering.
 148 bool BufferedResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
 149                                          int* buf_size,
 150                                          int min_size) {
 151   if (state_ == STATE_STREAMING)
 152     return next_handler_->OnWillRead(buf, buf_size, min_size);
 153
 154   DCHECK_EQ(-1, min_size);
 155
 156   if (read_buffer_.get()) {
 157     CHECK_LT(bytes_read_, read_buffer_size_);
 158     *buf = new DependentIOBuffer(read_buffer_.get(), bytes_read_);
 159     *buf_size = read_buffer_size_ - bytes_read_;
 160   } else {
 161     if (!next_handler_->OnWillRead(buf, buf_size, min_size))
 162       return false;
 163
 164     read_buffer_ = *buf;
 165     read_buffer_size_ = *buf_size;
 166     DCHECK_GE(read_buffer_size_, net::kMaxBytesToSniff * 2);
 167   }
 168   return true;
 169 }
 170
 171 bool BufferedResourceHandler::OnReadCompleted(int bytes_read, bool* defer) {
 172   if (state_ == STATE_STREAMING)
 173     return next_handler_->OnReadCompleted(bytes_read, defer);
 174
 175   DCHECK_EQ(state_, STATE_BUFFERING);
 176   bytes_read_ += bytes_read;
 177
 178   if (!DetermineMimeType() && (bytes_read > 0))
 179     return true;  // Needs more data, so keep buffering.
 180
 181   state_ = STATE_PROCESSING;
 182   return ProcessResponse(defer);
 183 }
 184
 185 void BufferedResourceHandler::OnResponseCompleted(
 186     const net::URLRequestStatus& status,
 187     const std::string& security_info,
 188     bool* defer) {
 189   // Upon completion, act like a pass-through handler in case the downstream
 190   // handler defers OnResponseCompleted.
 191   state_ = STATE_STREAMING;
 192
 193   next_handler_->OnResponseCompleted(status, security_info, defer);
 194 }
 195
 196 void BufferedResourceHandler::Resume() {
 197   switch (state_) {
 198     case STATE_BUFFERING:
 199     case STATE_PROCESSING:
 200       NOTREACHED();
 201       break;
 202     case STATE_REPLAYING:
 203       base::MessageLoop::current()->PostTask(
 204           FROM_HERE,
 205           base::Bind(&BufferedResourceHandler::CallReplayReadCompleted,
 206                      weak_ptr_factory_.GetWeakPtr()));
 207       break;
 208     case STATE_STARTING:
 209     case STATE_STREAMING:
 210       controller()->Resume();
 211       break;
 212   }
 213 }
 214
 215 void BufferedResourceHandler::Cancel() {
 216   controller()->Cancel();
 217 }
 218
 219 void BufferedResourceHandler::CancelAndIgnore() {
 220   controller()->CancelAndIgnore();
 221 }
 222
 223 void BufferedResourceHandler::CancelWithError(int error_code) {
 224   controller()->CancelWithError(error_code);
 225 }
 226
 227 bool BufferedResourceHandler::ProcessResponse(bool* defer) {
 228   DCHECK_EQ(STATE_PROCESSING, state_);
 229
 230   // TODO(darin): Stop special-casing 304 responses.
 231   if (!(response_->head.headers.get() &&
 232         response_->head.headers->response_code() == 304)) {
 233     if (!SelectNextHandler(defer))
 234       return false;
 235     if (*defer)
 236       return true;
 237   }
 238
 239   state_ = STATE_REPLAYING;
 240
 241   if (!next_handler_->OnResponseStarted(response_.get(), defer))
 242     return false;
 243
 244   if (!read_buffer_.get()) {
 245     state_ = STATE_STREAMING;
 246     return true;
 247   }
 248
 249   if (!*defer)
 250     return ReplayReadCompleted(defer);
 251
 252   return true;
 253 }
 254
 255 bool BufferedResourceHandler::ShouldSniffContent() {
 256   const std::string& mime_type = response_->head.mime_type;
 257
 258   std::string content_type_options;
 259   request()->GetResponseHeaderByName("x-content-type-options",
 260                                      &content_type_options);
 261
 262   bool sniffing_blocked =
 263       LowerCaseEqualsASCII(content_type_options, "nosniff");
 264   bool we_would_like_to_sniff =
 265       net::ShouldSniffMimeType(request()->url(), mime_type);
 266
 267   RecordSnifferMetrics(sniffing_blocked, we_would_like_to_sniff, mime_type);
 268
 269   if (!sniffing_blocked && we_would_like_to_sniff) {
 270     // We're going to look at the data before deciding what the content type
 271     // is.  That means we need to delay sending the ResponseStarted message
 272     // over the IPC channel.
 273     VLOG(1) << "To buffer: " << request()->url().spec();
 274     return true;
 275   }
 276
 277   return false;
 278 }
 279
 280 bool BufferedResourceHandler::DetermineMimeType() {
 281   DCHECK_EQ(STATE_BUFFERING, state_);
 282
 283   const std::string& type_hint = response_->head.mime_type;
 284
 285   std::string new_type;
 286   bool made_final_decision =
 287       net::SniffMimeType(read_buffer_->data(), bytes_read_, request()->url(),
 288                          type_hint, &new_type);
 289
 290   // SniffMimeType() returns false if there is not enough data to determine
 291   // the mime type. However, even if it returns false, it returns a new type
 292   // that is probably better than the current one.
 293   response_->head.mime_type.assign(new_type);
 294
 295   return made_final_decision;
 296 }
 297
 298 bool BufferedResourceHandler::SelectNextHandler(bool* defer) {
 299   DCHECK(!response_->head.mime_type.empty());
 300
 301   ResourceRequestInfoImpl* info = GetRequestInfo();
 302   const std::string& mime_type = response_->head.mime_type;
 303
 304   if (net::IsSupportedCertificateMimeType(mime_type)) {
 305     // Install certificate file.
 306     info->set_is_download(true);
 307     scoped_ptr<ResourceHandler> handler(
 308         new CertificateResourceHandler(request()));
 309     return UseAlternateNextHandler(handler.Pass(), std::string());
 310   }
 311
 312   if (!info->allow_download())
 313     return true;
 314
 315   bool must_download = MustDownload();
 316   if (!must_download) {
 317     if (net::IsSupportedMimeType(mime_type))
 318       return true;
 319
 320     std::string payload;
 321     scoped_ptr<ResourceHandler> handler(
 322         host_->MaybeInterceptAsStream(request(), response_.get(), &payload));
 323     if (handler) {
 324       return UseAlternateNextHandler(handler.Pass(), payload);
 325     }
 326
 327 #if defined(ENABLE_PLUGINS)
 328     bool stale;
 329     bool has_plugin = HasSupportingPlugin(&stale);
 330     if (stale) {
 331       // Refresh the plugins asynchronously.
 332       PluginServiceImpl::GetInstance()->GetPlugins(
 333           base::Bind(&BufferedResourceHandler::OnPluginsLoaded,
 334                      weak_ptr_factory_.GetWeakPtr()));
 335       request()->LogBlockedBy("BufferedResourceHandler");
 336       *defer = true;
 337       return true;
 338     }
 339     if (has_plugin)
 340       return true;
 341 #endif
 342   }
 343
 344   // Install download handler
 345   info->set_is_download(true);
 346   scoped_ptr<ResourceHandler> handler(
 347       host_->CreateResourceHandlerForDownload(
 348           request(),
 349           true,  // is_content_initiated
 350           must_download,
 351           content::DownloadItem::kInvalidId,
 352           scoped_ptr<DownloadSaveInfo>(new DownloadSaveInfo()),
 353           DownloadUrlParameters::OnStartedCallback()));
 354   return UseAlternateNextHandler(handler.Pass(), std::string());
 355 }
 356
 357 bool BufferedResourceHandler::UseAlternateNextHandler(
 358     scoped_ptr<ResourceHandler> new_handler,
 359     const std::string& payload_for_old_handler) {
 360   if (response_->head.headers.get() &&  // Can be NULL if FTP.
 361       response_->head.headers->response_code() / 100 != 2) {
 362     // The response code indicates that this is an error page, but we don't
 363     // know how to display the content.  We follow Firefox here and show our
 364     // own error page instead of triggering a download.
 365     // TODO(abarth): We should abstract the response_code test, but this kind
 366     //               of check is scattered throughout our codebase.
 367     request()->CancelWithError(net::ERR_INVALID_RESPONSE);
 368     return false;
 369   }
 370
 371   // Inform the original ResourceHandler that this will be handled entirely by
 372   // the new ResourceHandler.
 373   // TODO(darin): We should probably check the return values of these.
 374   bool defer_ignored = false;
 375   next_handler_->OnResponseStarted(response_.get(), &defer_ignored);
 376   // Although deferring OnResponseStarted is legal, the only downstream handler
 377   // which does so is CrossSiteResourceHandler. Cross-site transitions should
 378   // not trigger when switching handlers.
 379   DCHECK(!defer_ignored);
 380   if (payload_for_old_handler.empty()) {
 381     net::URLRequestStatus status(net::URLRequestStatus::CANCELED,
 382                                  net::ERR_ABORTED);
 383     next_handler_->OnResponseCompleted(status, std::string(), &defer_ignored);
 384     DCHECK(!defer_ignored);
 385   } else {
 386     scoped_refptr<net::IOBuffer> buf;
 387     int size = 0;
 388
 389     next_handler_->OnWillRead(&buf, &size, -1);
 390     CHECK_GE(size, static_cast<int>(payload_for_old_handler.length()));
 391
 392     memcpy(buf->data(), payload_for_old_handler.c_str(),
 393            payload_for_old_handler.length());
 394
 395     next_handler_->OnReadCompleted(payload_for_old_handler.length(),
 396                                    &defer_ignored);
 397     DCHECK(!defer_ignored);
 398
 399     net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
 400     next_handler_->OnResponseCompleted(status, std::string(), &defer_ignored);
 401     DCHECK(!defer_ignored);
 402   }
 403
 404   // This is handled entirely within the new ResourceHandler, so just reset the
 405   // original ResourceHandler.
 406   next_handler_ = new_handler.Pass();
 407   next_handler_->SetController(this);
 408
 409   return CopyReadBufferToNextHandler();
 410 }
 411
 412 bool BufferedResourceHandler::ReplayReadCompleted(bool* defer) {
 413   DCHECK(read_buffer_.get());
 414
 415   bool result = next_handler_->OnReadCompleted(bytes_read_, defer);
 416
 417   read_buffer_ = NULL;
 418   read_buffer_size_ = 0;
 419   bytes_read_ = 0;
 420
 421   state_ = STATE_STREAMING;
 422
 423   return result;
 424 }
 425
 426 void BufferedResourceHandler::CallReplayReadCompleted() {
 427   bool defer = false;
 428   if (!ReplayReadCompleted(&defer)) {
 429     controller()->Cancel();
 430   } else if (!defer) {
 431     state_ = STATE_STREAMING;
 432     controller()->Resume();
 433   }
 434 }
 435
 436 bool BufferedResourceHandler::MustDownload() {
 437   if (must_download_is_set_)
 438     return must_download_;
 439
 440   must_download_is_set_ = true;
 441
 442   std::string disposition;
 443   request()->GetResponseHeaderByName("content-disposition", &disposition);
 444   if (!disposition.empty() &&
 445       net::HttpContentDisposition(disposition, std::string()).is_attachment()) {
 446     must_download_ = true;
 447   } else if (host_->delegate() &&
 448              host_->delegate()->ShouldForceDownloadResource(
 449                  request()->url(), response_->head.mime_type)) {
 450     must_download_ = true;
 451   } else {
 452     must_download_ = false;
 453   }
 454
 455   return must_download_;
 456 }
 457
 458 bool BufferedResourceHandler::HasSupportingPlugin(bool* stale) {
 459 #if defined(ENABLE_PLUGINS)
 460   ResourceRequestInfoImpl* info = GetRequestInfo();
 461
 462   bool allow_wildcard = false;
 463   WebPluginInfo plugin;
 464   return PluginServiceImpl::GetInstance()->GetPluginInfo(
 465       info->GetChildID(), info->GetRenderFrameID(), info->GetContext(),
 466       request()->url(), GURL(), response_->head.mime_type, allow_wildcard,
 467       stale, &plugin, NULL);
 468 #else
 469   if (stale)
 470     *stale = false;
 471   return false;
 472 #endif
 473 }
 474
 475 bool BufferedResourceHandler::CopyReadBufferToNextHandler() {
 476   if (!read_buffer_.get())
 477     return true;
 478
 479   scoped_refptr<net::IOBuffer> buf;
 480   int buf_len = 0;
 481   if (!next_handler_->OnWillRead(&buf, &buf_len, bytes_read_))
 482     return false;
 483
 484   CHECK((buf_len >= bytes_read_) && (bytes_read_ >= 0));
 485   memcpy(buf->data(), read_buffer_->data(), bytes_read_);
 486   return true;
 487 }
 488
 489 void BufferedResourceHandler::OnPluginsLoaded(
 490     const std::vector<WebPluginInfo>& plugins) {
 491   request()->LogUnblocked();
 492   bool defer = false;
 493   if (!ProcessResponse(&defer)) {
 494     controller()->Cancel();
 495   } else if (!defer) {
 496     controller()->Resume();
 497   }
 498 }
 499
 500 }  // namespace content