Move MimeTypeResourceHandler before ThrottlingResourceHandler

content/browser/loader/intercepting_resource_handler.cc

Index: content/browser/loader/intercepting_resource_handler.cc
diff --git a/content/browser/loader/intercepting_resource_handler.cc b/content/browser/loader/intercepting_resource_handler.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8d795a8b8103afe2b650504110118ea0f28af748
--- /dev/null
+++ b/content/browser/loader/intercepting_resource_handler.cc
@@ -0,0 +1,164 @@
+// Copyright 2016 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/intercepting_resource_handler.h"
+
+#include <utility>
+
+#include "base/logging.h"
+#include "base/strings/string_util.h"
+#include "content/public/common/resource_response.h"
+#include "net/base/io_buffer.h"
+
+namespace content {
+
+InterceptingResourceHandler::InterceptingResourceHandler(
+    std::unique_ptr<ResourceHandler> next_handler,
+    net::URLRequest* request)
+    : LayeredResourceHandler(request, std::move(next_handler)),
+      state_(State::STARTING),
+      first_read_buffer_size_(0) {}
+
+InterceptingResourceHandler::~InterceptingResourceHandler() {}
+
+void InterceptingResourceHandler::UseNewHandler(
+    std::unique_ptr<ResourceHandler> new_handler,
+    const std::string& payload_for_old_handler) {
+  new_handler_ = std::move(new_handler);
+  new_handler_->SetController(controller());
+  payload_for_old_handler_ = payload_for_old_handler;
+}
+
+bool InterceptingResourceHandler::OnResponseStarted(ResourceResponse* response,
+                                                    bool* defer) {
+  // If there's no need to switch handlers, just start acting as a blind
+  // pass-through ResourceHandler.
+  if (!new_handler_) {
+    state_ = State::DONE;
+    first_read_buffer_ = nullptr;
+    return next_handler_->OnResponseStarted(response, defer);
+  }
+
+  // Otherwise, switch handlers. First, inform the original ResourceHandler
+  // that this will be handled entirely by the new ResourceHandler.
+  // TODO(clamy): We will probably need to check the return values of these for
+  // PlzNavigate.
+  bool defer_ignored = false;
+  next_handler_->OnResponseStarted(response, &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);
+
+  // Make a copy of the data in the first read buffer. This data should be
+  // passed to the alternate ResourceHandler and not to to the current
+  // ResourceHandler.
+  if (first_read_buffer_) {
+    first_read_buffer_copy_ = new net::IOBuffer(first_read_buffer_size_);
+    memcpy(first_read_buffer_copy_->data(), first_read_buffer_->data(),
+           first_read_buffer_size_);

[mmenke, 2016/07/25 17:39:31]

Do our memory tools complain if we end up copying uninitialized memory here? 
Not that I see an easy way around that without modifying behavior.

[clamy, 2016/07/26 16:24:15]

Asan bot seems alright with it. To avoid that, the only solution would be to
keep both handlers around until we get the OnReadCompleted where we know the
data size. I'm not sure this is preferable.

+  }
+
+  // Send the payload to the old handler.
+  SendPayloadToOldHandler();
+  first_read_buffer_ = nullptr;
+
+  // This is now handled entirely within the new ResourceHandler, so just reset
+  // the original ResourceHandler.
+  next_handler_ = std::move(new_handler_);
+
+  state_ =
+      first_read_buffer_copy_ ? State::WAITING_FOR_BUFFER_COPY : State::DONE;
+
+  return next_handler_->OnResponseStarted(response, defer);
+}
+
+bool InterceptingResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
+                                             int* buf_size,
+                                             int min_size) {
+  if (state_ == State::DONE)
+    return next_handler_->OnWillRead(buf, buf_size, min_size);
+
+  DCHECK_EQ(State::STARTING, state_);
+  DCHECK_EQ(-1, min_size);
+
+  if (!next_handler_->OnWillRead(buf, buf_size, min_size))
+    return false;
+
+  first_read_buffer_ = *buf;
+  first_read_buffer_size_ = *buf_size;
+  return true;
+}
+
+bool InterceptingResourceHandler::OnReadCompleted(int bytes_read, bool* defer) {
+  if (state_ == State::DONE)
+    return next_handler_->OnReadCompleted(bytes_read, defer);
+
+  DCHECK_EQ(State::WAITING_FOR_BUFFER_COPY, state_);
+  state_ = State::DONE;
+
+  // Copy the data from the first read to the new ResourceHandler.
+  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));
+  CHECK_GE(first_read_buffer_size_, static_cast<size_t>(bytes_read));
+  memcpy(buf->data(), first_read_buffer_copy_->data(), bytes_read);
+
+  first_read_buffer_copy_ = nullptr;
+
+  return next_handler_->OnReadCompleted(bytes_read, defer);
+}
+
+void InterceptingResourceHandler::SendPayloadToOldHandler() {
+  bool defer_ignored = false;
+  if (payload_for_old_handler_.empty()) {
+    // If there is no payload, just finalize the request on the old handler.
+    net::URLRequestStatus status(net::URLRequestStatus::CANCELED,
+                                 net::ERR_ABORTED);
+    next_handler_->OnResponseCompleted(status, std::string(), &defer_ignored);
+    DCHECK(!defer_ignored);
+    return;
+  }
+
+  // Ensure the old ResourceHandler has a buffer that can store the payload.
+  scoped_refptr<net::IOBuffer> buf;
+  int size = 0;
+  if (first_read_buffer_ &&
+      first_read_buffer_size_ >= payload_for_old_handler_.length()) {
+    // The first read buffer can be reused. The data inside it has been copied
+    // before calling this function, so it can safely be overriden.
+    buf = first_read_buffer_;
+    size = first_read_buffer_size_;
+  } else if (first_read_buffer_ &&
+             first_read_buffer_size_ < payload_for_old_handler_.length()) {
+    // Simulate a read of size 0 to safely call OnWillRead with the right size
+    // on the old ResourceHandler.

[mmenke, 2016/07/25 17:39:31]

Does this case ever help?  first_read_buffer_ was allocated from a previous call
to next_handler_->OnWillRead(&buf, &size, -1);.  Why would a new call with the
exact same arguments allocate enough memory, if the first call did not?

[clamy, 2016/07/26 16:24:15]

Good point. Removed this case.

+    next_handler_->OnReadCompleted(0, &defer_ignored);
+    DCHECK(!defer_ignored);
+  }
+
+  // If the first read buffer cannot be reused, ask the old ResourceHandler to
+  // create a buffer that can contain payload.
+  if (!buf)
+    next_handler_->OnWillRead(&buf, &size, -1);
+
+  CHECK(buf);
+  CHECK_GE(size, static_cast<int>(payload_for_old_handler_.length()));
+  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);
+
+  // Finalize the request.
+  net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
+  next_handler_->OnResponseCompleted(status, std::string(), &defer_ignored);
+  DCHECK(!defer_ignored);
+}
+
+}  // namespace content