Move MimeTypeResourceHandler before ThrottlingResourceHandler

content/browser/loader/mime_type_resource_handler.cc

Index: content/browser/loader/mime_type_resource_handler.cc
diff --git a/content/browser/loader/mime_type_resource_handler.cc b/content/browser/loader/mime_type_resource_handler.cc
index ab4fca3a8dbdc4780fb66e01878e11c1a5aa31eb..ba1c828c7fb5a0939f83521de7b9f78375b05845 100644
--- a/content/browser/loader/mime_type_resource_handler.cc
+++ b/content/browser/loader/mime_type_resource_handler.cc
@@ -32,10 +32,8 @@
 #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 {
 
@@ -53,9 +51,7 @@ const char kDefaultAcceptHeader[] = "*/*";
 class DependentIOBuffer : public net::WrappedIOBuffer {
  public:
   DependentIOBuffer(net::IOBuffer* buf, int offset)
-      : net::WrappedIOBuffer(buf->data() + offset),
-        buf_(buf) {
-  }
+      : net::WrappedIOBuffer(buf->data() + offset), buf_(buf) {}
 
  private:
   ~DependentIOBuffer() override {}
@@ -76,10 +72,10 @@ MimeTypeResourceHandler::MimeTypeResourceHandler(
 #if defined(ENABLE_PLUGINS)
       plugin_service_(plugin_service),
 #endif
-      read_buffer_size_(0),
-      bytes_read_(0),
       must_download_(false),
       must_download_is_set_(false),
+      read_buffer_size_(0),
+      bytes_read_(0),
       weak_ptr_factory_(this) {
 }
 
@@ -89,45 +85,13 @@ 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.
+  // Downstream handlers see the MimeTypeResourceHandler 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 MimeTypeResourceHandler::OnResponseStarted(ResourceResponse* response,
-                                                bool* defer) {
-  response_ = response;
-
-  // 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");
-    }
-  }
-
-  state_ = STATE_PROCESSING;
-  return ProcessResponse(defer);
-}
-
 bool MimeTypeResourceHandler::OnWillStart(const GURL& url, bool* defer) {
   const char* accept_value = nullptr;
   switch (GetRequestInfo()->GetResourceType()) {
@@ -168,6 +132,37 @@ bool MimeTypeResourceHandler::OnWillStart(const GURL& url, bool* defer) {
   return next_handler_->OnWillStart(url, defer);
 }
 
+bool MimeTypeResourceHandler::OnResponseStarted(ResourceResponse* response,
+                                                bool* defer) {
+  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;
+
+    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 ProcessReplay(defer);
+}
+
 bool MimeTypeResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
                                          int* buf_size,
                                          int min_size) {
@@ -198,11 +193,22 @@ bool MimeTypeResourceHandler::OnReadCompleted(int bytes_read, bool* defer) {
   DCHECK_EQ(state_, STATE_BUFFERING);
   bytes_read_ += bytes_read;
 
-  if (!DetermineMimeType() && (bytes_read > 0))
-    return true;  // Needs more data, so keep buffering.
+  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);
 
-  state_ = STATE_PROCESSING;
-  return ProcessResponse(defer);
+  if (!made_final_decision && (bytes_read > 0))
+    return true;
+
+  return ProcessReplay(defer);
 }
 
 void MimeTypeResourceHandler::OnResponseCompleted(
@@ -216,22 +222,47 @@ void MimeTypeResourceHandler::OnResponseCompleted(
   next_handler_->OnResponseCompleted(status, security_info, defer);
 }
 
+void MimeTypeResourceHandler::InstallNewLeafHandler(
+    std::unique_ptr<ResourceHandler> new_handler,
+    const std::string& payload_for_old_handler) {
+  // If acting as a pass-through handler, install the new leaf handler right
+  // away.
+  if (state_ == STATE_STARTING || state_ == STATE_STREAMING) {
+    LayeredResourceHandler::InstallNewLeafHandler(std::move(new_handler),
+                                                  payload_for_old_handler);

[mmenke, 2016/06/02 19:56:19]

Why is this no longer always done synchronously?

+    return;
+  }
+
+  // Store the handler so that it can be properly installed when replaying the
+  // response.
+  new_leaf_handler_ = std::move(new_handler);
+  payload_for_old_handler_ = payload_for_old_handler;
+  new_leaf_handler_->SetController(this);
+}
+
 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;
+  // If no information is currently being transmitted to downstream handlers,
+  // they should not attempt to resume the request.
+  if (state_ == STATE_BUFFERING || state_ == STATE_PROCESSING) {
+    NOTREACHED();
+    return;
+  }
+
+  // If the BufferingHandler is acting as a pass-through handler, just ask the
+  // upwards ResourceController to resume the request.
+  if (state_ == STATE_STARTING || state_ == STATE_STREAMING) {
+    controller()->Resume();
+    return;
+  }
+
+  // Otherwise proceed with the replay of the response. If it is successful,
+  // resume the request.
+  bool defer = false;
+  if (!ProcessReplay(&defer)) {
+    Cancel();
+  } else if (!defer) {
+    DCHECK(state_ == STATE_STREAMING);
+    controller()->Resume();
   }
 }
 
@@ -247,32 +278,92 @@ void MimeTypeResourceHandler::CancelWithError(int error_code) {
   controller()->CancelWithError(error_code);
 }
 
-bool MimeTypeResourceHandler::ProcessResponse(bool* defer) {
-  DCHECK_EQ(STATE_PROCESSING, state_);
+bool MimeTypeResourceHandler::ProcessReplay(bool* defer) {
+  bool return_value = true;
+  while (!*defer && return_value && state_ != STATE_STREAMING) {
+    switch (state_) {
+      case STATE_BUFFERING:
+        return_value = MaybeStartReplay(defer);
+        break;
+      case STATE_PROCESSING:
+        return_value = ReplayResponseReceived(defer);
+        break;
+      case STATE_REPLAYING_RESPONSE_RECEIVED:
+        return_value = ReplayResponseReceivedNewHandler(defer);
+        break;
+      case STATE_REPLAYING_RESPONSE_RECEIVED_NEW_HANDLER:
+        return_value = ReplayReadCompleted(defer);
+        break;
+      default:
+        NOTREACHED();
+        break;
+    }
+  }
+  return return_value;
+}
 
+bool MimeTypeResourceHandler::MaybeStartReplay(bool* defer) {
   // 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 (*defer)
+    state_ = STATE_BUFFERING;
+  else
+    state_ = STATE_PROCESSING;
 
-  if (!next_handler_->OnResponseStarted(response_.get(), defer))
-    return false;
+  return true;
+}
 
-  if (!read_buffer_.get()) {
-    state_ = STATE_STREAMING;
-    return true;
+bool MimeTypeResourceHandler::ReplayResponseReceived(bool* defer) {
+  DCHECK(state_ == STATE_PROCESSING);
+  state_ = STATE_REPLAYING_RESPONSE_RECEIVED;
+  return next_handler_->OnResponseStarted(response_.get(), defer);
+}
+
+bool MimeTypeResourceHandler::ReplayResponseReceivedNewHandler(bool* defer) {
+  DCHECK(state_ == STATE_REPLAYING_RESPONSE_RECEIVED);
+  state_ = STATE_REPLAYING_RESPONSE_RECEIVED_NEW_HANDLER;
+  if (new_leaf_handler_)
+    return new_leaf_handler_->OnResponseStarted(response_.get(), defer);
+  return true;
+}
+
+bool MimeTypeResourceHandler::ReplayReadCompleted(bool* defer) {
+  DCHECK(state_ == STATE_REPLAYING_RESPONSE_RECEIVED_NEW_HANDLER);
+
+  // First, install the new leaf ResourceHandler (if any), before calling
+  // OnReadCompleted on the downstream ResourceHandlers. This should also take
+  // care of delivering the payload for the old ResourceHandler.
+  if (new_leaf_handler_) {
+    // Copy the buffered data to the new leaf ResourceHandler if needed.
+    if (read_buffer_.get()) {
+      scoped_refptr<net::IOBuffer> new_buffer;
+      int buf_len = 0;
+      if (!new_leaf_handler_->OnWillRead(&new_buffer, &buf_len, bytes_read_))
+        return false;
+      CHECK((buf_len >= bytes_read_) && (bytes_read_ >= 0));
+      memcpy(new_buffer->data(), read_buffer_->data(), bytes_read_);
+    }
+    LayeredResourceHandler::InstallNewLeafHandler(std::move(new_leaf_handler_),
+                                                  payload_for_old_handler_);
   }
 
-  if (!*defer)
-    return ReplayReadCompleted(defer);
+  state_ = STATE_STREAMING;
 
-  return true;
+  if (!read_buffer_.get())
+    return true;
+
+  bool result = next_handler_->OnReadCompleted(bytes_read_, defer);
+
+  read_buffer_ = NULL;
+  read_buffer_size_ = 0;
+  bytes_read_ = 0;
+
+  return result;
 }
 
 bool MimeTypeResourceHandler::ShouldSniffContent() {
@@ -298,24 +389,6 @@ bool MimeTypeResourceHandler::ShouldSniffContent() {
   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) {
   *handled_by_plugin = false;
@@ -430,69 +503,9 @@ bool MimeTypeResourceHandler::UseAlternateNextHandler(
     return false;
   }
 
-  // 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(response_.get(), &defer_ignored);
-  // Although deferring OnResponseStarted is legal, the only downstream handler
-  // which does so is CrossSiteResourceHandler. Cross-site transitions should
-  // not trigger when switching handlers.
-  DCHECK(!defer_ignored);
-  if (payload_for_old_handler.empty()) {
-    net::URLRequestStatus status(net::URLRequestStatus::CANCELED,
-                                 net::ERR_ABORTED);
-    next_handler_->OnResponseCompleted(status, std::string(), &defer_ignored);
-    DCHECK(!defer_ignored);
-  } else {
-    scoped_refptr<net::IOBuffer> buf;
-    int size = 0;
-
-    next_handler_->OnWillRead(&buf, &size, -1);
-    CHECK_GE(size, static_cast<int>(payload_for_old_handler.length()));
+  InstallNewLeafHandler(std::move(new_handler), payload_for_old_handler);
 
-    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);
-
-    net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
-    next_handler_->OnResponseCompleted(status, std::string(), &defer_ignored);
-    DCHECK(!defer_ignored);
-  }
-
-  // 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;
-
-  state_ = STATE_STREAMING;
-
-  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() {
@@ -517,25 +530,11 @@ bool MimeTypeResourceHandler::MustDownload() {
   return must_download_;
 }
 
-bool MimeTypeResourceHandler::CopyReadBufferToNextHandler() {
-  if (!read_buffer_.get())
-    return true;
-
-  scoped_refptr<net::IOBuffer> buf;
-  int buf_len = 0;
-  if (!next_handler_->OnWillRead(&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 MimeTypeResourceHandler::OnPluginsLoaded(
     const std::vector<WebPluginInfo>& plugins) {
   request()->LogUnblocked();
   bool defer = false;
-  if (!ProcessResponse(&defer)) {
+  if (!ProcessReplay(&defer)) {
     controller()->Cancel();
   } else if (!defer) {
     controller()->Resume();