Have MimeSniffingResourceHandler call WillStartRequest on new Handlers.

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 258 matching lines @@
   }
 }
 
 bool MimeSniffingResourceHandler::ProcessState(bool* defer) {
   bool return_value = true;
   while (!*defer && return_value && state_ != STATE_STREAMING) {
     switch (state_) {
       case STATE_BUFFERING:
         return_value = MaybeIntercept(defer);
         break;
-      case STATE_INTERCEPTION_CHECK_DONE:
-        return_value = ReplayResponseReceived(defer);
+      case STATE_NEED_TO_PREPARE_TO_USE_NEW_HANDLER:
+        return_value = PrepareToUseNewHandler(defer);
         break;
-      case STATE_REPLAYING_RESPONSE_RECEIVED:
+      case STATE_PREPARING_TO_USE_NEW_HANDLER:
+        return_value = ReplayReceivedResponse(defer);
+        break;
+      case STATE_REPLAYING_RECEIVED_RESPONSE:
         return_value = ReplayReadCompleted(defer);
         break;
       default:
         NOTREACHED();
         break;
     }
   }
   return return_value;
 }
 
 bool MimeSniffingResourceHandler::MaybeIntercept(bool* defer) {
   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;
 
   if (!*defer)
-    state_ = STATE_INTERCEPTION_CHECK_DONE;
+    state_ = STATE_NEED_TO_PREPARE_TO_USE_NEW_HANDLER;
 
   return true;
 }
 
-bool MimeSniffingResourceHandler::ReplayResponseReceived(bool* defer) {
-  DCHECK_EQ(STATE_INTERCEPTION_CHECK_DONE, state_);
-  state_ = STATE_REPLAYING_RESPONSE_RECEIVED;
+bool MimeSniffingResourceHandler::PrepareToUseNewHandler(bool* defer) {
+  DCHECK_EQ(STATE_NEED_TO_PREPARE_TO_USE_NEW_HANDLER, state_);
+  state_ = STATE_PREPARING_TO_USE_NEW_HANDLER;
+  if (!new_handler_)
+    return true;
+
+  // The InterceptingResourceHandler's OnWillStart method has already been
+  // called, so need to call it on the new ResourceHandler before it can be
+  // swapped in to take its place.  Redirects will not be passed to the new
+  // handler.
+  // TODO(mmenke):  If the request is cancelled while new_handler_ is
+  // non-NULL, the new handler will not get an OnResponseCompleted call
+  // before being deleted.  Is that worth fixing?
+
+  // Temporarily set NewHandler's ResourceController, so it can cancel /
+  // pause / resume the request, if needed.  It ultimately should use
+  // InterceptingHandler's ResourceController, but if cancels the request,
+  // it shouldn't go through that ResourceController, as it would be
+  // calling into the controller when the controller may not think the
+  // ball is currently in its court.
+  new_handler_->SetController(this);
+
+  return new_handler_->OnWillStart(request()->url(), defer);
+}
+
+bool MimeSniffingResourceHandler::ReplayReceivedResponse(bool* defer) {
+  DCHECK_EQ(STATE_PREPARING_TO_USE_NEW_HANDLER, state_);
+
+  // Swap in new handler, if there is one.
+  if (new_handler_) {
+    // Clear the controller.
+    new_handler_->SetController(nullptr);
+
+    intercepting_handler_->UseNewHandler(std::move(new_handler_),
+                                         std::move(payload_for_old_handler_));
+  }
+
+  state_ = STATE_REPLAYING_RECEIVED_RESPONSE;
   return next_handler_->OnResponseStarted(response_.get(), defer);
 }
 
 bool MimeSniffingResourceHandler::ReplayReadCompleted(bool* defer) {
-  DCHECK_EQ(STATE_REPLAYING_RESPONSE_RECEIVED, state_);
+  DCHECK_EQ(STATE_REPLAYING_RECEIVED_RESPONSE, state_);
 
   state_ = STATE_STREAMING;
 
   if (!read_buffer_.get())
     return true;
 
   bool result = next_handler_->OnReadCompleted(bytes_read_, defer);
 
   read_buffer_ = nullptr;
   read_buffer_size_ = 0;
@@ skipping 80 matching lines @@
     if (handled_by_plugin || *defer)
       return true;
   }
 
   // This is request is a download,
 
   if (!CheckResponseIsNotProvisional())
     return false;
 
   info->set_is_download(true);
-  std::unique_ptr<ResourceHandler> handler(
+  new_handler_ =
       host_->CreateResourceHandlerForDownload(request(),
                                               true,  // is_content_initiated
-                                              must_download));
-  intercepting_handler_->UseNewHandler(std::move(handler), std::string());
+                                              must_download);
   return true;
 }
 
 bool MimeSniffingResourceHandler::CheckForPluginHandler(
     bool* defer,
     bool* handled_by_plugin) {
   *handled_by_plugin = false;
 #if defined(ENABLE_PLUGINS)
   ResourceRequestInfoImpl* info = GetRequestInfo();
   bool allow_wildcard = false;
@@ skipping 16 matching lines @@
 
   if (has_plugin && plugin.type != WebPluginInfo::PLUGIN_TYPE_BROWSER_PLUGIN) {
     *handled_by_plugin = true;
     return true;
   }
 
   // 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) {
+  new_handler_ = host_->MaybeInterceptAsStream(
+      plugin_path, request(), response_.get(), &payload_for_old_handler_);
+  if (new_handler_) {
     if (!CheckResponseIsNotProvisional())
       return false;
     *handled_by_plugin = true;
-    intercepting_handler_->UseNewHandler(std::move(handler), payload);
   }
 #endif
   return true;
 }
 
 bool MimeSniffingResourceHandler::CanBeIntercepted() {
   if (response_->head.headers.get() &&
       response_->head.headers->response_code() == 304) {
     return false;
   }
@@ skipping 41 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