When InterceptingResourceHandler swaps in a handler, call OnWillStart.

content/browser/loader/intercepting_resource_handler.cc

 // 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 "base/logging.h"
 #include "base/strings/string_util.h"
 #include "content/public/common/resource_response.h"
 #include "net/base/io_buffer.h"
+#include "net/url_request/url_request.h"
 
 namespace content {
 
 InterceptingResourceHandler::InterceptingResourceHandler(
     std::unique_ptr<ResourceHandler> next_handler,
     net::URLRequest* request)
     : LayeredResourceHandler(request, std::move(next_handler)) {
   next_handler_->SetController(this);
 }
 
@@ skipping 147 matching lines @@
 
 bool InterceptingResourceHandler::DoLoop(bool* defer) {
   bool result = true;
   do {
     switch (state_) {
       case State::STARTING:
       case State::WAITING_FOR_ON_READ_COMPLETED:
       case State::PASS_THROUGH:
         NOTREACHED();
         break;
-      case State::NOTIFYING_ON_RESPONSE_STARTED_TO_NEW_HANDLER:
+      case State::SENDING_ON_WILL_START_TO_NEW_HANDLER:
+        result = SendOnResponseStartedToNewHandler(defer);
+        break;
+      case State::SENDING_ON_RESPONSE_STARTED_TO_NEW_HANDLER:
         if (first_read_buffer_double_) {
           // OnWillRead has been called, so copying the data from
           // |first_read_buffer_double_| to |first_read_buffer_| will be needed
           // when OnReadCompleted is called.
           state_ = State::WAITING_FOR_ON_READ_COMPLETED;
         } else {
           // OnWillRead has not been called, so no special handling will be
           // needed from now on.
           state_ = State::PASS_THROUGH;
           next_handler_->SetController(controller());
@@ skipping 43 matching lines @@
 
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
   if (payload_for_old_handler_.empty()) {
     // If there is no payload, just finalize the request on the old handler.
     status = net::URLRequestStatus::FromError(net::ERR_ABORTED);
   }
   next_handler_->OnResponseCompleted(status, defer);
   DCHECK(!*defer);
 
   next_handler_ = std::move(new_handler_);
-  state_ = State::NOTIFYING_ON_RESPONSE_STARTED_TO_NEW_HANDLER;
+  state_ = State::SENDING_ON_WILL_START_TO_NEW_HANDLER;
+  return next_handler_->OnWillStart(request()->url(), defer);
+}
+
+bool InterceptingResourceHandler::SendOnResponseStartedToNewHandler(
+    bool* defer) {
+  state_ = State::SENDING_ON_RESPONSE_STARTED_TO_NEW_HANDLER;
   return next_handler_->OnResponseStarted(response_.get(), defer);
 }
 
 bool InterceptingResourceHandler::SendFirstReadBufferToNewHandler(bool* defer) {
   DCHECK_EQ(state_, State::SENDING_BUFFER_TO_NEW_HANDLER);
 
   while (first_read_buffer_bytes_written_ < first_read_buffer_bytes_read_) {
     scoped_refptr<net::IOBuffer> buf;
     int size = 0;
     if (!next_handler_->OnWillRead(&buf, &size, -1))
@@ skipping 10 matching lines @@
       return true;
   }
 
   state_ = State::PASS_THROUGH;
   first_read_buffer_double_ = nullptr;
   next_handler_->SetController(controller());
   return true;
 }
 
 }  // namespace content