Refactor ResourceHandler API.

content/browser/loader/mime_sniffing_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/mime_sniffing_resource_handler.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 81 matching lines @@
     ResourceController* controller) {
   ResourceHandler::SetController(controller);
 
   // Downstream handlers see the MimeSniffingResourceHandler as their
   // ResourceController, which allows it 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 MimeSniffingResourceHandler::OnWillStart(const GURL& url, bool* defer) {
+void MimeSniffingResourceHandler::OnWillStart(const GURL& url,
+                                              bool* defer_or_cancel) {
   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_FAVICON:
@@ skipping 16 matching lines @@
       accept_value = kDefaultAcceptHeader;
       break;
     case RESOURCE_TYPE_LAST_TYPE:
       NOTREACHED();
       break;
   }
 
   // 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);
+  next_handler_->OnWillStart(url, defer_or_cancel);
 }
 
-bool MimeSniffingResourceHandler::OnResponseStarted(ResourceResponse* response,
-                                                    bool* defer) {
+void MimeSniffingResourceHandler::OnResponseStarted(ResourceResponse* response,
+                                                    bool* defer_or_cancel) {
   DCHECK_EQ(STATE_STARTING, state_);
   response_ = response;
 
   state_ = STATE_BUFFERING;
   // 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())
-      return true;
+      return;
 
     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");
     }
   }
 
-  return ProcessState(defer);
+  ProcessState(defer_or_cancel);
 }
 
 bool MimeSniffingResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
                                              int* buf_size,
                                              int min_size) {
   if (state_ == STATE_STREAMING)
     return next_handler_->OnWillRead(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 {
     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);
   }
   return true;
 }
 
-bool MimeSniffingResourceHandler::OnReadCompleted(int bytes_read, bool* defer) {
-  if (state_ == STATE_STREAMING)
-    return next_handler_->OnReadCompleted(bytes_read, defer);
+void MimeSniffingResourceHandler::OnReadCompleted(int bytes_read,
+                                                  bool* defer_or_cancel) {
+  if (state_ == STATE_STREAMING) {
+    next_handler_->OnReadCompleted(bytes_read, defer_or_cancel);
+    return;
+  }
 
   DCHECK_EQ(state_, STATE_BUFFERING);
   bytes_read_ += bytes_read;
 
   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);
 
   if (!made_final_decision && (bytes_read > 0))
-    return true;
+    return;
 
-  return ProcessState(defer);
+  ProcessState(defer_or_cancel);
 }
 
 void MimeSniffingResourceHandler::OnResponseCompleted(
     const net::URLRequestStatus& status,
     bool* defer) {
   // Upon completion, act like a pass-through handler in case the downstream
   // handler defers OnResponseCompleted.
   state_ = STATE_STREAMING;
 
   next_handler_->OnResponseCompleted(status, defer);
@@ skipping 25 matching lines @@
 
 void MimeSniffingResourceHandler::CancelAndIgnore() {
   controller()->CancelAndIgnore();
 }
 
 void MimeSniffingResourceHandler::CancelWithError(int error_code) {
   controller()->CancelWithError(error_code);
 }
 
 void MimeSniffingResourceHandler::AdvanceState() {
-  bool defer = false;
-  if (!ProcessState(&defer)) {
-    Cancel();
-  } else if (!defer) {
+  bool defer_or_cancel = false;
+  ProcessState(&defer_or_cancel);
+  if (!defer_or_cancel) {
     DCHECK_EQ(STATE_STREAMING, state_);
     controller()->Resume();
   }
 }
 
-bool MimeSniffingResourceHandler::ProcessState(bool* defer) {
-  bool return_value = true;
-  while (!*defer && return_value && state_ != STATE_STREAMING) {
+void MimeSniffingResourceHandler::ProcessState(bool* defer_or_cancel) {
+  while (!*defer_or_cancel && state_ != STATE_STREAMING) {
     switch (state_) {
       case STATE_BUFFERING:
-        return_value = MaybeIntercept(defer);
+        MaybeIntercept(defer_or_cancel);
         break;
       case STATE_INTERCEPTION_CHECK_DONE:
-        return_value = ReplayResponseReceived(defer);
+        ReplayResponseReceived(defer_or_cancel);
         break;
       case STATE_REPLAYING_RESPONSE_RECEIVED:
-        return_value = ReplayReadCompleted(defer);
+        ReplayReadCompleted(defer_or_cancel);
         break;
       default:
         NOTREACHED();
         break;
     }
   }
-  return return_value;
 }
 
-bool MimeSniffingResourceHandler::MaybeIntercept(bool* defer) {
+void MimeSniffingResourceHandler::MaybeIntercept(bool* defer_or_cancel) {
   DCHECK_EQ(STATE_BUFFERING, state_);
   // If a request that can be intercepted failed the check for interception
   // step, it should be canceled.
-  if (!MaybeStartInterception(defer))
-    return false;
+  MaybeStartInterception(defer_or_cancel);
 
-  if (!*defer)
+  if (!*defer_or_cancel)
     state_ = STATE_INTERCEPTION_CHECK_DONE;
-
-  return true;
 }
 
-bool MimeSniffingResourceHandler::ReplayResponseReceived(bool* defer) {
+void MimeSniffingResourceHandler::ReplayResponseReceived(
+    bool* defer_or_cancel) {
   DCHECK_EQ(STATE_INTERCEPTION_CHECK_DONE, state_);
   state_ = STATE_REPLAYING_RESPONSE_RECEIVED;
-  return next_handler_->OnResponseStarted(response_.get(), defer);
+  next_handler_->OnResponseStarted(response_.get(), defer_or_cancel);
 }
 
-bool MimeSniffingResourceHandler::ReplayReadCompleted(bool* defer) {
+void MimeSniffingResourceHandler::ReplayReadCompleted(bool* defer_or_cancel) {
   DCHECK_EQ(STATE_REPLAYING_RESPONSE_RECEIVED, state_);
 
   state_ = STATE_STREAMING;
 
   if (!read_buffer_.get())
-    return true;
+    return;
 
-  bool result = next_handler_->OnReadCompleted(bytes_read_, defer);
+  next_handler_->OnReadCompleted(bytes_read_, defer_or_cancel);
 
   read_buffer_ = nullptr;
   read_buffer_size_ = 0;
   bytes_read_ = 0;
-
-  return result;
 }
 
 bool MimeSniffingResourceHandler::ShouldSniffContent() {
   if (request_context_type_ == REQUEST_CONTEXT_TYPE_FETCH) {
     // MIME sniffing should be disabled for a request initiated by fetch().
     return false;
   }
 
   const std::string& mime_type = response_->head.mime_type;
 
@@ skipping 10 matching lines @@
     // 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 MimeSniffingResourceHandler::MaybeStartInterception(bool* defer) {
+void MimeSniffingResourceHandler::MaybeStartInterception(
+    bool* defer_or_cancel) {
   if (!CanBeIntercepted())
-    return true;
+    return;
 
   DCHECK(!response_->head.mime_type.empty());
 
   ResourceRequestInfoImpl* info = GetRequestInfo();
   const std::string& mime_type = response_->head.mime_type;
 
   // https://crbug.com/568184 - Temporary hack to track servers that aren't
   // setting Content-Disposition when sending x-x509-user-cert and expecting
   // the browser to automatically install certificates; this is being
   // deprecated and will be removed upon full <keygen> removal.
   if (mime_type == "application/x-x509-user-cert" && response_->head.headers) {
     UMA_HISTOGRAM_BOOLEAN(
         "UserCert.ContentDisposition",
         response_->head.headers->HasHeader("Content-Disposition"));
   }
 
   // Allow requests for object/embed tags to be intercepted as streams.
   if (info->GetResourceType() == content::RESOURCE_TYPE_OBJECT) {
     DCHECK(!info->allow_download());
 
     bool handled_by_plugin;
-    if (!CheckForPluginHandler(defer, &handled_by_plugin))
-      return false;
-    if (handled_by_plugin || *defer)
-      return true;
+    CheckForPluginHandler(defer_or_cancel, &handled_by_plugin);
+    if (handled_by_plugin || *defer_or_cancel)
+      return;
   }
 
   if (!info->allow_download())
-    return true;
+    return;
 
   // info->allow_download() == true implies
   // info->GetResourceType() == RESOURCE_TYPE_MAIN_FRAME or
   // info->GetResourceType() == RESOURCE_TYPE_SUB_FRAME.
   DCHECK(info->GetResourceType() == RESOURCE_TYPE_MAIN_FRAME ||
          info->GetResourceType() == RESOURCE_TYPE_SUB_FRAME);
 
   bool must_download = MustDownload();
   if (!must_download) {
     if (mime_util::IsSupportedMimeType(mime_type))
-      return true;
+      return;
 
     bool handled_by_plugin;
-    if (!CheckForPluginHandler(defer, &handled_by_plugin))
-      return false;
-    if (handled_by_plugin || *defer)
-      return true;
+    CheckForPluginHandler(defer_or_cancel, &handled_by_plugin);
+    if (handled_by_plugin || *defer_or_cancel)
+      return;
   }
 
   // This request is a download.
 
-  if (!CheckResponseIsNotProvisional())
-    return false;
+  if (!CheckResponseIsNotProvisional()) {
+    *defer_or_cancel = true;
+    controller()->Cancel();
+    return;
+  }
 
   info->set_is_download(true);
   std::unique_ptr<ResourceHandler> handler(
       host_->CreateResourceHandlerForDownload(request(),
                                               true,  // is_content_initiated
                                               must_download,
                                               false /* is_new_request */));
   intercepting_handler_->UseNewHandler(std::move(handler), std::string());
-  return true;
 }
 
-bool MimeSniffingResourceHandler::CheckForPluginHandler(
-    bool* defer,
+void MimeSniffingResourceHandler::CheckForPluginHandler(
+    bool* defer_or_cancel,
     bool* handled_by_plugin) {
   *handled_by_plugin = false;
 #if defined(ENABLE_PLUGINS)
   ResourceRequestInfoImpl* info = GetRequestInfo();
   bool allow_wildcard = false;
   bool stale;
   WebPluginInfo plugin;
   bool has_plugin = plugin_service_->GetPluginInfo(
       info->GetChildID(), info->GetRenderFrameID(), info->GetContext(),
       request()->url(), url::Origin(), response_->head.mime_type,
       allow_wildcard, &stale, &plugin, NULL);
 
   if (stale) {
     // Refresh the plugins asynchronously.
     plugin_service_->GetPlugins(
         base::Bind(&MimeSniffingResourceHandler::OnPluginsLoaded,
                    weak_ptr_factory_.GetWeakPtr()));
     request()->LogBlockedBy("MimeSniffingResourceHandler");
-    *defer = true;
-    return true;
+    *defer_or_cancel = true;
+    return;
   }
 
   if (has_plugin && plugin.type != WebPluginInfo::PLUGIN_TYPE_BROWSER_PLUGIN) {
     *handled_by_plugin = true;
-    return true;
+    return;
   }
 
   // Attempt to intercept the request as a stream.
   base::FilePath plugin_path;
   if (has_plugin)
     plugin_path = plugin.path;
   std::string payload;
   std::unique_ptr<ResourceHandler> handler(host_->MaybeInterceptAsStream(
       plugin_path, request(), response_.get(), &payload));
   if (handler) {
-    if (!CheckResponseIsNotProvisional())
-      return false;
+    if (!CheckResponseIsNotProvisional()) {
+      controller()->Cancel();
+      *defer_or_cancel = true;
+      return;
+    }
     *handled_by_plugin = true;
     intercepting_handler_->UseNewHandler(std::move(handler), payload);
   }
 #endif
-  return true;
+  return;
 }
 
 bool MimeSniffingResourceHandler::CanBeIntercepted() {
   if (response_->head.headers.get() &&
       response_->head.headers->response_code() == 304) {
     return false;
   }
 
   return true;
 }
@@ skipping 38 matching lines @@
 
 void MimeSniffingResourceHandler::OnPluginsLoaded(
     const std::vector<WebPluginInfo>& plugins) {
   // No longer blocking on the plugins being loaded.
   request()->LogUnblocked();
   if (state_ == STATE_BUFFERING)
     AdvanceState();
 }
 
 }  // namespace content