Refactor ResourceHandler API.

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"
@@ skipping 10 matching lines @@
 
 InterceptingResourceHandler::~InterceptingResourceHandler() {}
 
 void InterceptingResourceHandler::SetController(
     ResourceController* controller) {
   if (state_ == State::PASS_THROUGH)
     return LayeredResourceHandler::SetController(controller);
   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,
                                              int* buf_size,
                                              int min_size) {
   if (state_ == State::PASS_THROUGH)
     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;
   first_read_buffer_double_ = new net::IOBuffer(static_cast<size_t>(*buf_size));
   *buf = first_read_buffer_double_;
   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_) {
       // |first_read_buffer_double_| was allocated and the user wrote data to
       // the buffer, but switching has not been done after all.
       memcpy(first_read_buffer_->data(), first_read_buffer_double_->data(),
              bytes_read);
       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(
     const net::URLRequestStatus& status,
     bool* defer) {
   if (state_ == State::PASS_THROUGH) {
     LayeredResourceHandler::OnResponseCompleted(status, defer);
     return;
   }
   if (!new_handler_) {
@@ skipping 36 matching lines @@
 }
 
 void InterceptingResourceHandler::Resume() {
   DCHECK_NE(State::PASS_THROUGH, state_);
   if (state_ == State::STARTING ||
       state_ == State::WAITING_FOR_ON_READ_COMPLETED) {
     // Uninteresting Resume: just delegate to the original resource controller.
     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();
 }
 
 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(this);
   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:
       case State::WAITING_FOR_ON_READ_COMPLETED:
       case State::PASS_THROUGH:
         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_) {
           // 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());
         }
         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;
     int size = 0;
     if (first_read_buffer_) {
       // |first_read_buffer_| is a buffer gotten from |next_handler_| via
       // OnWillRead. Use the buffer.
       buffer = first_read_buffer_;
       size = first_read_buffer_size_;
 
       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);
   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);
+
+  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