Clean up ResourceHandler API.

content/browser/loader/buffered_resource_handler.cc

 // 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/loader/buffered_resource_handler.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 62 matching lines @@
 
   scoped_refptr<net::IOBuffer> buf_;
 };
 
 }  // namespace
 
 BufferedResourceHandler::BufferedResourceHandler(
     scoped_ptr<ResourceHandler> next_handler,
     ResourceDispatcherHostImpl* host,
     net::URLRequest* request)
-    : LayeredResourceHandler(next_handler.Pass()),
+    : LayeredResourceHandler(request, 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() {
 }
 
@@ skipping 43 matching lines @@
       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) {
+bool BufferedResourceHandler::OnWillRead(int request_id,
+                                         scoped_refptr<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_.get()) {
     CHECK_LT(bytes_read_, read_buffer_size_);
     *buf = new DependentIOBuffer(read_buffer_.get(), bytes_read_);
     *buf_size = read_buffer_size_ - bytes_read_;
   } else {
@@ skipping 71 matching lines @@
   if (!(response_->head.headers.get() &&
         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_.get(), defer))
+  if (!next_handler_->OnResponseStarted(GetRequestID(), response_.get(), defer))
     return false;
 
   if (!read_buffer_.get()) {
     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);
+  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);
+      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();
+    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(),
+      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_);
+  ResourceRequestInfoImpl* info = GetRequestInfo();
   const std::string& mime_type = response_->head.mime_type;
 
   if (net::IsSupportedCertificateMimeType(mime_type)) {
     // Install certificate file.
     scoped_ptr<ResourceHandler> handler(
-        new CertificateResourceHandler(request_));
+        new CertificateResourceHandler(request()));
     return UseAlternateNextHandler(handler.Pass());
   }
 
   if (!info->allow_download())
     return true;
 
   bool must_download = MustDownload();
   if (!must_download) {
     if (net::IsSupportedMimeType(mime_type))
       return true;
 
     scoped_ptr<ResourceHandler> handler(
-        host_->MaybeInterceptAsStream(request_, response_.get()));
+        host_->MaybeInterceptAsStream(request(), response_.get()));
     if (handler)
       return UseAlternateNextHandler(handler.Pass());
 
 #if defined(ENABLE_PLUGINS)
     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;
 #endif
   }
 
   // Install download handler
   info->set_is_download(true);
   scoped_ptr<ResourceHandler> handler(
       host_->CreateResourceHandlerForDownload(
-          request_,
+          request(),
           true,  // is_content_initiated
           must_download,
           content::DownloadItem::kInvalidId,
           scoped_ptr<DownloadSaveInfo>(new DownloadSaveInfo()),
           DownloadUrlParameters::OnStartedCallback()));
   return UseAlternateNextHandler(handler.Pass());
 }
 
 bool BufferedResourceHandler::UseAlternateNextHandler(
     scoped_ptr<ResourceHandler> new_handler) {
   if (response_->head.headers.get() &&  // 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);
+    request()->CancelWithError(net::ERR_FILE_NOT_FOUND);
     return false;
   }
 
-  int request_id = ResourceRequestInfo::ForRequest(request_)->GetRequestID();
+  int request_id = 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_.get(), &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_.get());
 
-  int request_id = ResourceRequestInfo::ForRequest(request_)->GetRequestID();
-  bool result = next_handler_->OnReadCompleted(request_id, bytes_read_, defer);
+  bool result = next_handler_->OnReadCompleted(GetRequestID(), 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);
+  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)) {
+                 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_);
+  ResourceRequestInfoImpl* info = GetRequestInfo();
 
   bool allow_wildcard = false;
   WebPluginInfo plugin;
   return PluginServiceImpl::GetInstance()->GetPluginInfo(
       info->GetChildID(), info->GetRouteID(), info->GetContext(),
-      request_->url(), GURL(), response_->head.mime_type, allow_wildcard,
+      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;
+  scoped_refptr<net::IOBuffer> buf;
   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<WebPluginInfo>& plugins) {
   bool defer = false;
   if (!ProcessResponse(&defer)) {
     controller()->Cancel();
   } else if (!defer) {
     controller()->Resume();
   }
 }
 
 }  // namespace content