Move MimeTypeResourceHandler before ThrottlingResourceHandler

content/browser/loader/layered_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/layered_resource_handler.h"
 
 #include <utility>
 
 #include "base/logging.h"
+#include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
+#include "net/url_request/url_request.h"
 
 namespace content {
 
 LayeredResourceHandler::LayeredResourceHandler(
     net::URLRequest* request,
     std::unique_ptr<ResourceHandler> next_handler)
     : ResourceHandler(request), next_handler_(std::move(next_handler)) {}
 
 LayeredResourceHandler::~LayeredResourceHandler() {
 }
@@ skipping 53 matching lines @@
     bool* defer) {
   DCHECK(next_handler_.get());
   next_handler_->OnResponseCompleted(status, security_info, defer);
 }
 
 void LayeredResourceHandler::OnDataDownloaded(int bytes_downloaded) {
   DCHECK(next_handler_.get());
   next_handler_->OnDataDownloaded(bytes_downloaded);
 }
 
+bool LayeredResourceHandler::IsLeafHandler() const {
+  return false;
+}
+
+void LayeredResourceHandler::InstallNewLeafHandler(
+    std::unique_ptr<ResourceHandler> new_handler,
+    const std::string& payload_for_old_handler) {
+  if (!next_handler_->IsLeafHandler()) {
+    next_handler_->InstallNewLeafHandler(std::move(new_handler),
+                                         payload_for_old_handler);
+    return;
+  }
+
+  // Simulate a read of payload_for_old_handler and the end of the response on

[nasko, 2016/06/01 17:18:25]

This comment applies more to the else part of this statement.

+  // the next handler.
+  bool defer_ignored = false;
+  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()));

[nasko, 2016/06/01 17:18:25]

It is better to use checked_cast<> from base/numerics/safe_conversions.h to
avoid over/underflow.

+
+    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);
+  }
+
+  next_handler_ = std::move(new_handler);
+  next_handler_->SetController(controller());
+}
+
 }  // namespace content