Update MojoAsyncResourceHandler tests to use MockResourceLoader.

content/browser/loader/mock_resource_loader.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/mock_resource_loader.h"
 
 #include <memory>
 
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "content/browser/loader/resource_controller.h"
 #include "content/browser/loader/resource_handler.h"
-#include "net/base/io_buffer.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 MockResourceLoader::MockResourceLoader(ResourceHandler* resource_handler)
     : resource_handler_(resource_handler) {
   resource_handler_->SetController(this);
 }
 
@@ skipping 58 matching lines @@
   } else if (defer) {
     status_ = Status::CALLBACK_PENDING;
   } else {
     status_ = Status::IDLE;
   }
   return status_;
 }
 
 MockResourceLoader::Status MockResourceLoader::OnWillRead(int min_size) {
   EXPECT_EQ(Status::IDLE, status_);
+  EXPECT_FALSE(io_buffer_);
+  EXPECT_EQ(0, io_buffer_size_);
+
   status_ = Status::CALLING_HANDLER;
 
-  scoped_refptr<net::IOBuffer> buf;
-  int buf_size;
-  bool result = resource_handler_->OnWillRead(&buf, &buf_size, min_size);
+  bool result =
+      resource_handler_->OnWillRead(&io_buffer_, &io_buffer_size_, min_size);
   // The second case isn't really allowed, but a number of classes do it
   // anyways.
   EXPECT_TRUE(status_ == Status::CALLING_HANDLER ||
               (result == false && status_ == Status::CANCELED));
   if (!result) {
+    EXPECT_EQ(0, io_buffer_size_);
+    EXPECT_FALSE(io_buffer_);
     status_ = Status::CANCELED;
   } else {
-    EXPECT_LE(min_size, buf_size);
+    EXPECT_LE(min_size, io_buffer_size_);
+    EXPECT_LT(0, io_buffer_size_);
+    EXPECT_TRUE(io_buffer_);
     status_ = Status::IDLE;
   }
   return status_;
 };
 
-MockResourceLoader::Status MockResourceLoader::OnReadCompleted(int bytes_read) {
+MockResourceLoader::Status MockResourceLoader::OnReadCompleted(
+    base::StringPiece bytes) {
   EXPECT_EQ(Status::IDLE, status_);
+  EXPECT_LE(bytes.size(), io_buffer_size_);
+
+  status_ = Status::CALLING_HANDLER;
+  std::copy(bytes.begin(), bytes.end(), io_buffer_->data());
+  io_buffer_ = nullptr;
+  io_buffer_size_ = 0;
   status_ = Status::CALLING_HANDLER;
 
   bool defer = false;
-  bool result = resource_handler_->OnReadCompleted(bytes_read, &defer);
+  bool result = resource_handler_->OnReadCompleted(bytes.size(), &defer);
   // The second case isn't really allowed, but a number of classes do it
   // anyways.
   EXPECT_TRUE(status_ == Status::CALLING_HANDLER ||
               (result == false && status_ == Status::CANCELED));
   if (!result) {
     status_ = Status::CANCELED;
   } else if (defer) {
     status_ = Status::CALLBACK_PENDING;
   } else {
     status_ = Status::IDLE;
@@ skipping 15 matching lines @@
   resource_handler_->OnResponseCompleted(status, &defer);
   EXPECT_EQ(Status::CALLING_HANDLER, status_);
   if (defer) {
     status_ = Status::CALLBACK_PENDING;
   } else {
     status_ = Status::IDLE;
   }
   return status_;
 }
 
+MockResourceLoader::Status
+MockResourceLoader::OnResponseCompletedFromExternalOutOfBandCancel(
+    const net::URLRequestStatus& status) {

[Randy Smith (Not in Mondays), 2016/12/21 16:47:37]

nit, suggestion: This routine (and possibly other routines?) is a bit confusing
because of the use of similar variable names for different types
(MockResourceLoader::Status and URLRequestStatus).   Maybe an extra annotation
on one of the variable names?

[mmenke, 2017/01/05 18:50:25]

Done.

+  // This can happen at any point, except from a recursive call from
+  // ResourceHandler.
+  EXPECT_NE(Status::CALLING_HANDLER, status_);
+
+  status_ = Status::CALLING_HANDLER;
+
+  bool defer = false;
+  resource_handler_->OnResponseCompleted(status, &defer);
+  EXPECT_EQ(Status::CALLING_HANDLER, status_);
+  if (defer) {
+    status_ = Status::CALLBACK_PENDING;
+  } else {
+    status_ = Status::IDLE;
+  }
+  return status_;
+}
+
+void MockResourceLoader::WaitUntilIdleOrCanceled() {
+  if (status_ != Status::IDLE && status_ != Status::CANCELED) {
+    EXPECT_FALSE(canceled_or_idle_run_loop_);
+    canceled_or_idle_run_loop_.reset(new base::RunLoop());
+    canceled_or_idle_run_loop_->Run();
+    EXPECT_TRUE(status_ == Status::IDLE || status_ == Status::CANCELED);
+  }
+}
+
+void MockResourceLoader::ReleaseIOBuffer() {

[Randy Smith (Not in Mondays), 2016/12/21 16:47:37]

Is there a reason this can't be done automatically when OnReadCompleted()
succeeds?  

[mmenke, 2017/01/05 18:50:25]

MojoAsyncResourceHandlerTest.IOBufferFromOnWillReadShouldRemainValidEvenIfHandlerIsGone
wants direct access to it, to make sure that the custom IOBuffer class remains
usable after the MojoAsyncResourceHandler is destroyed, as the API contract
requires.

[Randy Smith (Not in Mondays), 2017/01/10 23:07:47]

If I understand this use case correctly, it could be addressed by just taking
another reference to the IOBuffer in that specific test, rather than having
another interface on MockResourceLoader.  But I'm happy to defer to your
preference.

+  io_buffer_ = nullptr;
+}
+
 void MockResourceLoader::Cancel() {
   CancelWithError(net::ERR_ABORTED);
 }
 
 void MockResourceLoader::CancelAndIgnore() {
   NOTREACHED();
 }
 
 void MockResourceLoader::CancelWithError(int error_code) {
   EXPECT_LT(error_code, 0);
   // Ignore double cancels.  Classes shouldn't be doing this, as
   // ResourceLoader doesn't really support it, but they do anywways.  :(
   // TODO(mmenke): Remove this check.
   if (error_code_ != net::OK)
     return;
 
   // ResourceLoader really expects canceled not to be called synchronously, but
   // a lot of code does it, so allow it.
   // TODO(mmenke):  Remove CALLING_HANDLER.
   EXPECT_TRUE(status_ == Status::CALLBACK_PENDING ||
               status_ == Status::CALLING_HANDLER || status_ == Status::IDLE);
   status_ = Status::CANCELED;
   error_code_ = error_code;
+  if (canceled_or_idle_run_loop_)
+    canceled_or_idle_run_loop_->Quit();
 }
 
 void MockResourceLoader::Resume() {
   EXPECT_EQ(Status::CALLBACK_PENDING, status_);
   status_ = Status::IDLE;
+  if (canceled_or_idle_run_loop_)
+    canceled_or_idle_run_loop_->Quit();
 }
 
 }  // namespace content