Refactor ResourceHandler API.

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
index 7c8f4a998641b711b9f5917198011a99269cad02..d93fe695fadca29ef0a4daa1ed1f6fc8a3e9fa7e 100644
--- a/content/browser/loader/intercepting_resource_handler.cc
+++ b/content/browser/loader/intercepting_resource_handler.cc
@@ -28,32 +28,30 @@ void InterceptingResourceHandler::SetController(
   ResourceHandler::SetController(controller);
 }
 
-bool InterceptingResourceHandler::OnResponseStarted(ResourceResponse* response,
-                                                    bool* defer) {
+void InterceptingResourceHandler::OnResponseStarted(ResourceResponse* response,
+                                                    bool* defer_or_cancel) {
   // If there's no need to switch handlers, just start acting as a blind
   // pass-through ResourceHandler.
   if (!new_handler_) {
     state_ = State::PASS_THROUGH;
     next_handler_->SetController(controller());
-    return next_handler_->OnResponseStarted(response, defer);
+    next_handler_->OnResponseStarted(response, defer_or_cancel);
+    return;
   }
 
   DCHECK_EQ(state_, State::STARTING);
-  // Otherwise, switch handlers. First, inform the original ResourceHandler
-  // that this will be handled entirely by the new ResourceHandler.
-  bool defer_ignored = false;
-  if (!next_handler_->OnResponseStarted(response, &defer_ignored))
-    return false;
-
-  // 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);
 
   // TODO(yhirano): Retaining ownership from a raw pointer is bad.
   response_ = response;
   state_ = State::SENDING_PAYLOAD_TO_OLD_HANDLER;
-  return DoLoop(defer);
+
+  // Otherwise, switch handlers. First, inform the original ResourceHandler
+  // that this will be handled entirely by the new ResourceHandler.
+  next_handler_->OnResponseStarted(response, defer_or_cancel);
+  if (*defer_or_cancel)
+    return;
+
+  DoLoop(defer_or_cancel);
 }
 
 bool InterceptingResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
@@ -75,7 +73,8 @@ bool InterceptingResourceHandler::OnWillRead(scoped_refptr<net::IOBuffer>* buf,
   return true;
 }
 
-bool InterceptingResourceHandler::OnReadCompleted(int bytes_read, bool* defer) {
+void InterceptingResourceHandler::OnReadCompleted(int bytes_read,
+                                                  bool* defer_or_cancel) {
   DCHECK_GE(bytes_read, 0);
   if (state_ == State::PASS_THROUGH) {
     if (first_read_buffer_double_) {
@@ -86,13 +85,14 @@ bool InterceptingResourceHandler::OnReadCompleted(int bytes_read, bool* defer) {
       first_read_buffer_ = nullptr;
       first_read_buffer_double_ = nullptr;
     }
-    return next_handler_->OnReadCompleted(bytes_read, defer);
+    next_handler_->OnReadCompleted(bytes_read, defer_or_cancel);
+    return;
   }
 
   DCHECK_EQ(State::WAITING_FOR_ON_READ_COMPLETED, state_);
   first_read_buffer_bytes_read_ = bytes_read;
   state_ = State::SENDING_BUFFER_TO_NEW_HANDLER;
-  return DoLoop(defer);
+  DoLoop(defer_or_cancel);
 }
 
 void InterceptingResourceHandler::OnResponseCompleted(
@@ -149,13 +149,10 @@ void InterceptingResourceHandler::Resume() {
     controller()->Resume();
     return;
   }
-  bool defer = false;
-  if (!DoLoop(&defer)) {
-    controller()->Cancel();
-    return;
-  }
+  bool defer_or_cancel = false;
+  DoLoop(&defer_or_cancel);
 
-  if (!defer)
+  if (!defer_or_cancel)
     controller()->Resume();
 }
 
@@ -167,8 +164,7 @@ void InterceptingResourceHandler::UseNewHandler(
   payload_for_old_handler_ = payload_for_old_handler;
 }
 
-bool InterceptingResourceHandler::DoLoop(bool* defer) {
-  bool result = true;
+void InterceptingResourceHandler::DoLoop(bool* defer_or_cancel) {
   do {
     switch (state_) {
       case State::STARTING:
@@ -177,7 +173,7 @@ bool InterceptingResourceHandler::DoLoop(bool* defer) {
         NOTREACHED();
         break;
       case State::SENDING_ON_WILL_START_TO_NEW_HANDLER:
-        result = SendOnResponseStartedToNewHandler(defer);
+        SendOnResponseStartedToNewHandler(defer_or_cancel);
         break;
       case State::SENDING_ON_RESPONSE_STARTED_TO_NEW_HANDLER:
         if (first_read_buffer_double_) {
@@ -193,19 +189,19 @@ bool InterceptingResourceHandler::DoLoop(bool* defer) {
         }
         break;
       case State::SENDING_PAYLOAD_TO_OLD_HANDLER:
-        result = SendPayloadToOldHandler(defer);
+        SendPayloadToOldHandler(defer_or_cancel);
         break;
       case State::SENDING_BUFFER_TO_NEW_HANDLER:
-        result = SendFirstReadBufferToNewHandler(defer);
+        SendFirstReadBufferToNewHandler(defer_or_cancel);
         break;
     }
-  } while (result && !*defer &&
+  } while (!*defer_or_cancel &&
            state_ != State::WAITING_FOR_ON_READ_COMPLETED &&
            state_ != State::PASS_THROUGH);
-  return result;
 }
 
-bool InterceptingResourceHandler::SendPayloadToOldHandler(bool* defer) {
+void InterceptingResourceHandler::SendPayloadToOldHandler(
+    bool* defer_or_cancel) {
   DCHECK_EQ(State::SENDING_PAYLOAD_TO_OLD_HANDLER, state_);
   while (payload_bytes_written_ < payload_for_old_handler_.size()) {
     scoped_refptr<net::IOBuffer> buffer;
@@ -219,19 +215,21 @@ bool InterceptingResourceHandler::SendPayloadToOldHandler(bool* defer) {
       first_read_buffer_ = nullptr;
       first_read_buffer_size_ = 0;
     } else {
-      if (!next_handler_->OnWillRead(&buffer, &size, -1))
-        return false;
+      if (!next_handler_->OnWillRead(&buffer, &size, -1)) {
+        *defer_or_cancel = true;
+        controller()->Cancel();
+        return;
+      }
     }
 
     size = std::min(size, static_cast<int>(payload_for_old_handler_.size() -
                                            payload_bytes_written_));
     memcpy(buffer->data(),
            payload_for_old_handler_.data() + payload_bytes_written_, size);
-    if (!next_handler_->OnReadCompleted(size, defer))
-      return false;
     payload_bytes_written_ += size;
-    if (*defer)
-      return true;
+    next_handler_->OnReadCompleted(size, defer_or_cancel);
+    if (*defer_or_cancel)
+      return;
   }
 
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
@@ -239,44 +237,48 @@ bool InterceptingResourceHandler::SendPayloadToOldHandler(bool* defer) {
     // 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);
+
+  DCHECK(!*defer_or_cancel);
+  next_handler_->OnResponseCompleted(status, defer_or_cancel);
+  DCHECK(!*defer_or_cancel);
 
   next_handler_ = std::move(new_handler_);
   state_ = State::SENDING_ON_WILL_START_TO_NEW_HANDLER;
-  return next_handler_->OnWillStart(request()->url(), defer);
+  next_handler_->OnWillStart(request()->url(), defer_or_cancel);
 }
 
-bool InterceptingResourceHandler::SendOnResponseStartedToNewHandler(
-    bool* defer) {
+void InterceptingResourceHandler::SendOnResponseStartedToNewHandler(
+    bool* defer_or_cancel) {
   state_ = State::SENDING_ON_RESPONSE_STARTED_TO_NEW_HANDLER;
-  return next_handler_->OnResponseStarted(response_.get(), defer);
+  next_handler_->OnResponseStarted(response_.get(), defer_or_cancel);
 }
 
-bool InterceptingResourceHandler::SendFirstReadBufferToNewHandler(bool* defer) {
+void InterceptingResourceHandler::SendFirstReadBufferToNewHandler(
+    bool* defer_or_cancel) {
   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))
-      return false;
+    if (!next_handler_->OnWillRead(&buf, &size, -1)) {
+      *defer_or_cancel = true;
+      controller()->Cancel();
+      return;
+    }
     size = std::min(size, static_cast<int>(first_read_buffer_bytes_read_ -
                                            first_read_buffer_bytes_written_));
     memcpy(buf->data(),
            first_read_buffer_double_->data() + first_read_buffer_bytes_written_,
            size);
-    if (!next_handler_->OnReadCompleted(size, defer))
-      return false;
     first_read_buffer_bytes_written_ += size;
-    if (*defer)
-      return true;
+    next_handler_->OnReadCompleted(size, defer_or_cancel);
+    if (*defer_or_cancel)
+      return;
   }
 
   state_ = State::PASS_THROUGH;
   first_read_buffer_double_ = nullptr;
   next_handler_->SetController(controller());
-  return true;
 }
 
 }  // namespace content