Skip to content

GitLab

T
tangled
Commit 5159f105 authored by mmenke's avatar mmenke Committed by Commit bot
Browse files
Options

Update MojoAsyncResourceHandler tests to use MockResourceLoader. 

TBR=clamy@chromium.org
BUG=659317

Review-Url: https://codereview.chromium.org/2581393002
Cr-Commit-Position: refs/heads/master@{#443263}
parent 063f0c9d
Show whitespace changes
Inline Side-by-side
Showing with 270 additions and 345 deletions
content/browser/loader/DEPS
View file @ 5159f105
...@@ -104,9 +104,9 @@ specific_include_rules = { ...@@ -104,9 +104,9 @@ specific_include_rules = {
], ],
"mojo_async_resource_handler_unittest\.cc": [ "mojo_async_resource_handler_unittest\.cc": [
"-content", "-content",
"+content/browser/loader/mock_resource_loader.h",
"+content/browser/loader/mojo_async_resource_handler.h", "+content/browser/loader/mojo_async_resource_handler.h",
"+content/browser/loader/test_url_loader_client.h", "+content/browser/loader/test_url_loader_client.h",
"+content/public/browser/navigation_data.h",
"+content/browser/loader/resource_controller.h", "+content/browser/loader/resource_controller.h",
"+content/browser/loader/resource_dispatcher_host_impl.h", "+content/browser/loader/resource_dispatcher_host_impl.h",
"+content/browser/loader/resource_request_info_impl.h", "+content/browser/loader/resource_request_info_impl.h",
...@@ -114,6 +114,7 @@ specific_include_rules = { ...@@ -114,6 +114,7 @@ specific_include_rules = {
"+content/common/resource_request_completion_status.h", "+content/common/resource_request_completion_status.h",
"+content/common/url_loader.mojom.h", "+content/common/url_loader.mojom.h",
"+content/public/browser/appcache_service.h", "+content/public/browser/appcache_service.h",
"+content/public/browser/navigation_data.h",
"+content/public/browser/resource_context.h", "+content/public/browser/resource_context.h",
"+content/public/browser/resource_dispatcher_host_delegate.h", "+content/public/browser/resource_dispatcher_host_delegate.h",
"+content/public/browser/resource_throttle.h", "+content/public/browser/resource_throttle.h",
......
content/browser/loader/mock_resource_loader.cc
View file @ 5159f105
...@@ -96,30 +96,43 @@ MockResourceLoader::Status MockResourceLoader::OnResponseStarted( ...@@ -96,30 +96,43 @@ MockResourceLoader::Status MockResourceLoader::OnResponseStarted(
MockResourceLoader::Status MockResourceLoader::OnWillRead(int min_size) { MockResourceLoader::Status MockResourceLoader::OnWillRead(int min_size) {
EXPECT_EQ(Status::IDLE, status_); EXPECT_EQ(Status::IDLE, status_);
EXPECT_FALSE(io_buffer_);
EXPECT_EQ(0, io_buffer_size_);
status_ = Status::CALLING_HANDLER; status_ = Status::CALLING_HANDLER;
scoped_refptr<net::IOBuffer> buf; bool result =
int buf_size; resource_handler_->OnWillRead(&io_buffer_, &io_buffer_size_, min_size);
bool result = resource_handler_->OnWillRead(&buf, &buf_size, min_size);
// The second case isn't really allowed, but a number of classes do it // The second case isn't really allowed, but a number of classes do it
// anyways. // anyways.
EXPECT_TRUE(status_ == Status::CALLING_HANDLER || EXPECT_TRUE(status_ == Status::CALLING_HANDLER ||
(result == false && status_ == Status::CANCELED)); (result == false && status_ == Status::CANCELED));
if (!result) { if (!result) {
EXPECT_EQ(0, io_buffer_size_);
EXPECT_FALSE(io_buffer_);
status_ = Status::CANCELED; status_ = Status::CANCELED;
} else { } 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; status_ = Status::IDLE;
} }
return status_; return status_;
}; };
MockResourceLoader::Status MockResourceLoader::OnReadCompleted(int bytes_read) { MockResourceLoader::Status MockResourceLoader::OnReadCompleted(
base::StringPiece bytes) {
EXPECT_EQ(Status::IDLE, status_); EXPECT_EQ(Status::IDLE, status_);
EXPECT_LE(bytes.size(), static_cast<size_t>(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; status_ = Status::CALLING_HANDLER;
bool defer = false; 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 // The second case isn't really allowed, but a number of classes do it
// anyways. // anyways.
EXPECT_TRUE(status_ == Status::CALLING_HANDLER || EXPECT_TRUE(status_ == Status::CALLING_HANDLER ||
...@@ -142,6 +155,8 @@ MockResourceLoader::Status MockResourceLoader::OnResponseCompleted( ...@@ -142,6 +155,8 @@ MockResourceLoader::Status MockResourceLoader::OnResponseCompleted(
(!status.is_success() && status_ == Status::CANCELED && (!status.is_success() && status_ == Status::CANCELED &&
error_code_ == status.error())); error_code_ == status.error()));
io_buffer_ = nullptr;
io_buffer_size_ = 0;
status_ = Status::CALLING_HANDLER; status_ = Status::CALLING_HANDLER;
bool defer = false; bool defer = false;
...@@ -155,6 +170,37 @@ MockResourceLoader::Status MockResourceLoader::OnResponseCompleted( ...@@ -155,6 +170,37 @@ MockResourceLoader::Status MockResourceLoader::OnResponseCompleted(
return status_; return status_;
} }
MockResourceLoader::Status
MockResourceLoader::OnResponseCompletedFromExternalOutOfBandCancel(
const net::URLRequestStatus& url_request_status) {
// This can happen at any point, except from a recursive call from
// ResourceHandler.
EXPECT_NE(Status::CALLING_HANDLER, status_);
io_buffer_ = nullptr;
io_buffer_size_ = 0;
status_ = Status::CALLING_HANDLER;
bool defer = false;
resource_handler_->OnResponseCompleted(url_request_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)
return;
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::Cancel() { void MockResourceLoader::Cancel() {
CancelWithError(net::ERR_ABORTED); CancelWithError(net::ERR_ABORTED);
} }
...@@ -178,11 +224,15 @@ void MockResourceLoader::CancelWithError(int error_code) { ...@@ -178,11 +224,15 @@ void MockResourceLoader::CancelWithError(int error_code) {
status_ == Status::CALLING_HANDLER || status_ == Status::IDLE); status_ == Status::CALLING_HANDLER || status_ == Status::IDLE);
status_ = Status::CANCELED; status_ = Status::CANCELED;
error_code_ = error_code; error_code_ = error_code;
if (canceled_or_idle_run_loop_)
canceled_or_idle_run_loop_->Quit();
} }
void MockResourceLoader::Resume() { void MockResourceLoader::Resume() {
EXPECT_EQ(Status::CALLBACK_PENDING, status_); EXPECT_EQ(Status::CALLBACK_PENDING, status_);
status_ = Status::IDLE; status_ = Status::IDLE;
if (canceled_or_idle_run_loop_)
canceled_or_idle_run_loop_->Quit();
} }
} // namespace content } // namespace content
content/browser/loader/mock_resource_loader.h
View file @ 5159f105
...@@ -10,7 +10,10 @@ ...@@ -10,7 +10,10 @@
#include "base/macros.h" #include "base/macros.h"
#include "base/memory/ref_counted.h" #include "base/memory/ref_counted.h"
#include "base/run_loop.h"
#include "base/strings/string_piece.h"
#include "content/browser/loader/resource_controller.h" #include "content/browser/loader/resource_controller.h"
#include "net/base/io_buffer.h"
#include "net/base/net_errors.h" #include "net/base/net_errors.h"
class GURL; class GURL;
...@@ -56,15 +59,31 @@ class MockResourceLoader : public ResourceController { ...@@ -56,15 +59,31 @@ class MockResourceLoader : public ResourceController {
scoped_refptr<ResourceResponse> response); scoped_refptr<ResourceResponse> response);
Status OnResponseStarted(scoped_refptr<ResourceResponse> response); Status OnResponseStarted(scoped_refptr<ResourceResponse> response);
Status OnWillRead(int min_size); Status OnWillRead(int min_size);
Status OnReadCompleted(int bytes_read); Status OnReadCompleted(base::StringPiece bytes);
Status OnResponseCompleted(const net::URLRequestStatus& status); Status OnResponseCompleted(const net::URLRequestStatus& status);
// Simulates an out-of-band cancel from some source other than the
// ResourceHandler |this| was created with (like another ResourceHandler). The
// difference between this and OnResponseCompleted() is that this has fewer
// sanity checks to validate the cancel was in-band.
Status OnResponseCompletedFromExternalOutOfBandCancel(
const net::URLRequestStatus& url_request_status);
// Waits until status() is IDLE or CANCELED. If that's already the case, does
// nothing.
void WaitUntilIdleOrCanceled();
Status status() const { return status_; } Status status() const { return status_; }
// Network error passed to the first CancelWithError() / Cancel() call, which // Network error passed to the first CancelWithError() / Cancel() call, which
// is the one the real code uses in the case of multiple cancels. // is the one the real code uses in the case of multiple cancels.
int error_code() const { return error_code_; } int error_code() const { return error_code_; }
// Returns IOBuffer returned by last call to OnWillRead. The IOBuffer is
// release on read complete, on response complete, and on cancel.
net::IOBuffer* io_buffer() const { return io_buffer_.get(); }
int io_buffer_size() const { return io_buffer_size_; }
private: private:
// ResourceController implementation. // ResourceController implementation.
void Cancel() override; void Cancel() override;
...@@ -77,6 +96,11 @@ class MockResourceLoader : public ResourceController { ...@@ -77,6 +96,11 @@ class MockResourceLoader : public ResourceController {
Status status_ = Status::IDLE; Status status_ = Status::IDLE;
int error_code_ = net::OK; int error_code_ = net::OK;
scoped_refptr<net::IOBuffer> io_buffer_;
int io_buffer_size_ = 0;
std::unique_ptr<base::RunLoop> canceled_or_idle_run_loop_;
DISALLOW_COPY_AND_ASSIGN(MockResourceLoader); DISALLOW_COPY_AND_ASSIGN(MockResourceLoader);
}; };
......
content/browser/loader/mojo_async_resource_handler_unittest.cc
View file @ 5159f105
...@@ -14,6 +14,7 @@ ...@@ -14,6 +14,7 @@
#include "base/memory/ptr_util.h" #include "base/memory/ptr_util.h"
#include "base/memory/weak_ptr.h" #include "base/memory/weak_ptr.h"
#include "base/run_loop.h" #include "base/run_loop.h"
#include "content/browser/loader/mock_resource_loader.h"
#include "content/browser/loader/resource_controller.h" #include "content/browser/loader/resource_controller.h"
#include "content/browser/loader/resource_dispatcher_host_impl.h" #include "content/browser/loader/resource_dispatcher_host_impl.h"
#include "content/browser/loader/resource_request_info_impl.h" #include "content/browser/loader/resource_request_info_impl.h"
...@@ -41,10 +42,8 @@ ...@@ -41,10 +42,8 @@
#include "net/http/http_status_code.h" #include "net/http/http_status_code.h"
#include "net/http/http_util.h" #include "net/http/http_util.h"
#include "net/ssl/client_cert_store.h" #include "net/ssl/client_cert_store.h"
#include "net/test/url_request/url_request_failed_job.h"
#include "net/url_request/url_request.h" #include "net/url_request/url_request.h"
#include "net/url_request/url_request_context.h" #include "net/url_request/url_request_context.h"
#include "net/url_request/url_request_filter.h"
#include "net/url_request/url_request_status.h" #include "net/url_request/url_request_status.h"
#include "net/url_request/url_request_test_util.h" #include "net/url_request/url_request_test_util.h"
#include "testing/gtest/include/gtest/gtest.h" #include "testing/gtest/include/gtest/gtest.h"
...@@ -174,55 +173,6 @@ class TestResourceDispatcherHostDelegate final ...@@ -174,55 +173,6 @@ class TestResourceDispatcherHostDelegate final
DISALLOW_COPY_AND_ASSIGN(TestResourceDispatcherHostDelegate); DISALLOW_COPY_AND_ASSIGN(TestResourceDispatcherHostDelegate);
}; };
class TestResourceController : public ResourceController {
public:
TestResourceController() {}
~TestResourceController() override {}
void Cancel() override { ADD_FAILURE() << "Cancel should not be called."; }
void CancelAndIgnore() override {
ADD_FAILURE() << "CancelAndIgnore should not be called.";
}
void CancelWithError(int error_code) override {
// While cancelling more than once is legal, none of these tests should do
// it.
EXPECT_FALSE(is_cancel_with_error_called_);
is_cancel_with_error_called_ = true;
error_ = error_code;
if (quit_closure_)
quit_closure_.Run();
}
void Resume() override { ++num_resume_calls_; }
void RunUntilCancelWithErrorCalled() {
base::RunLoop run_loop;
quit_closure_ = run_loop.QuitClosure();
run_loop.Run();
}
void set_quit_closure(const base::Closure& quit_closure) {
quit_closure_ = quit_closure;
}
bool is_cancel_with_error_called() const {
return is_cancel_with_error_called_;
}
int error() const { return error_; }
int num_resume_calls() const { return num_resume_calls_; }
private:
bool is_cancel_with_error_called_ = false;
int error_ = net::OK;
int num_resume_calls_ = 0;
base::Closure quit_closure_;
DISALLOW_COPY_AND_ASSIGN(TestResourceController);
};
class MojoAsyncResourceHandlerWithCustomDataPipeOperations class MojoAsyncResourceHandlerWithCustomDataPipeOperations
: public MojoAsyncResourceHandler { : public MojoAsyncResourceHandler {
public: public:
...@@ -319,12 +269,12 @@ class MojoAsyncResourceHandlerTestBase { ...@@ -319,12 +269,12 @@ class MojoAsyncResourceHandlerTestBase {
MojoAsyncResourceHandler::SetAllocationSizeForTesting(32 * 1024); MojoAsyncResourceHandler::SetAllocationSizeForTesting(32 * 1024);
rdh_.SetDelegate(&rdh_delegate_); rdh_.SetDelegate(&rdh_delegate_);
url_request_delegate_.reset(new net::TestDelegate()); // Create and initialize |request_|. None of this matters, for these tests,
// just need something non-NULL.
net::URLRequestContext* request_context = net::URLRequestContext* request_context =
browser_context_->GetResourceContext()->GetRequestContext(); browser_context_->GetResourceContext()->GetRequestContext();
request_ = request_context->CreateRequest( request_ = request_context->CreateRequest(
net::URLRequestFailedJob::GetMockHttpUrl(net::ERR_TIMED_OUT), GURL("http://foo/"), net::DEFAULT_PRIORITY, &url_request_delegate_);
net::DEFAULT_PRIORITY, url_request_delegate_.get());
ResourceRequestInfo::AllocateForTesting( ResourceRequestInfo::AllocateForTesting(
request_.get(), // request request_.get(), // request
RESOURCE_TYPE_XHR, // resource_type RESOURCE_TYPE_XHR, // resource_type
...@@ -360,46 +310,30 @@ class MojoAsyncResourceHandlerTestBase { ...@@ -360,46 +310,30 @@ class MojoAsyncResourceHandlerTestBase {
handler_.reset(new MojoAsyncResourceHandlerWithCustomDataPipeOperations( handler_.reset(new MojoAsyncResourceHandlerWithCustomDataPipeOperations(
request_.get(), &rdh_, factory_impl->PassLoaderRequest(), request_.get(), &rdh_, factory_impl->PassLoaderRequest(),
std::move(client_ptr))); std::move(client_ptr)));
handler_->SetController(&resource_controller_); mock_loader_.reset(new MockResourceLoader(handler_.get()));
} }
virtual ~MojoAsyncResourceHandlerTestBase() { virtual ~MojoAsyncResourceHandlerTestBase() {
net::URLRequestFilter::GetInstance()->ClearHandlers();
MojoAsyncResourceHandler::SetAllocationSizeForTesting( MojoAsyncResourceHandler::SetAllocationSizeForTesting(
MojoAsyncResourceHandler::kDefaultAllocationSize); MojoAsyncResourceHandler::kDefaultAllocationSize);
base::RunLoop().RunUntilIdle(); base::RunLoop().RunUntilIdle();
} }
// Returns false if something bad happens.
bool CallOnWillStart() {
bool defer = false;
if (!handler_->OnWillStart(request_->url(), &defer)) {
ADD_FAILURE() << "OnWillStart returns false.";
return false;
}
if (defer) {
ADD_FAILURE() << "OnWillStart sets |defer| true.";
return false;
}
return true;
}
// Returns false if something bad happens. // Returns false if something bad happens.
bool CallOnWillStartAndOnResponseStarted() { bool CallOnWillStartAndOnResponseStarted() {
rdh_delegate_.set_num_on_response_started_calls_expectation(1); rdh_delegate_.set_num_on_response_started_calls_expectation(1);
if (!CallOnWillStart()) MockResourceLoader::Status result =
mock_loader_->OnWillStart(request_->url());
EXPECT_EQ(MockResourceLoader::Status::IDLE, result);
if (result != MockResourceLoader::Status::IDLE)
return false; return false;
scoped_refptr<ResourceResponse> response = new ResourceResponse(); result = mock_loader_->OnResponseStarted(
bool defer = false; make_scoped_refptr(new ResourceResponse()));
if (!handler_->OnResponseStarted(response.get(), &defer)) { EXPECT_EQ(MockResourceLoader::Status::IDLE, result);
ADD_FAILURE() << "OnResponseStarted returns false."; if (result != MockResourceLoader::Status::IDLE)
return false; return false;
}
if (defer) {
ADD_FAILURE() << "OnResponseStarted sets |defer| true.";
return false;
}
if (url_loader_client_.has_received_response()) { if (url_loader_client_.has_received_response()) {
ADD_FAILURE() << "URLLoaderClient unexpectedly gets a response."; ADD_FAILURE() << "URLLoaderClient unexpectedly gets a response.";
return false; return false;
...@@ -414,12 +348,12 @@ class MojoAsyncResourceHandlerTestBase { ...@@ -414,12 +348,12 @@ class MojoAsyncResourceHandlerTestBase {
mojom::URLLoaderFactoryPtr url_loader_factory_; mojom::URLLoaderFactoryPtr url_loader_factory_;
mojom::URLLoaderAssociatedPtr url_loader_proxy_; mojom::URLLoaderAssociatedPtr url_loader_proxy_;
TestURLLoaderClient url_loader_client_; TestURLLoaderClient url_loader_client_;
TestResourceController resource_controller_;
std::unique_ptr<TestBrowserContext> browser_context_; std::unique_ptr<TestBrowserContext> browser_context_;
std::unique_ptr<net::TestDelegate> url_request_delegate_; net::TestDelegate url_request_delegate_;
std::unique_ptr<net::URLRequest> request_; std::unique_ptr<net::URLRequest> request_;
std::unique_ptr<MojoAsyncResourceHandlerWithCustomDataPipeOperations> std::unique_ptr<MojoAsyncResourceHandlerWithCustomDataPipeOperations>
handler_; handler_;
std::unique_ptr<MockResourceLoader> mock_loader_;
DISALLOW_COPY_AND_ASSIGN(MojoAsyncResourceHandlerTestBase); DISALLOW_COPY_AND_ASSIGN(MojoAsyncResourceHandlerTestBase);
}; };
...@@ -445,14 +379,14 @@ TEST_F(MojoAsyncResourceHandlerTest, InFlightRequests) { ...@@ -445,14 +379,14 @@ TEST_F(MojoAsyncResourceHandlerTest, InFlightRequests) {
} }
TEST_F(MojoAsyncResourceHandlerTest, OnWillStart) { TEST_F(MojoAsyncResourceHandlerTest, OnWillStart) {
bool defer = false; EXPECT_EQ(MockResourceLoader::Status::IDLE,
EXPECT_TRUE(handler_->OnWillStart(request_->url(), &defer)); mock_loader_->OnWillStart(request_->url()));
EXPECT_FALSE(defer);
} }
TEST_F(MojoAsyncResourceHandlerTest, OnResponseStarted) { TEST_F(MojoAsyncResourceHandlerTest, OnResponseStarted) {
rdh_delegate_.set_num_on_response_started_calls_expectation(1); rdh_delegate_.set_num_on_response_started_calls_expectation(1);
ASSERT_TRUE(CallOnWillStart()); ASSERT_EQ(MockResourceLoader::Status::IDLE,
mock_loader_->OnWillStart(request_->url()));
scoped_refptr<ResourceResponse> response = new ResourceResponse(); scoped_refptr<ResourceResponse> response = new ResourceResponse();
response->head.content_length = 99; response->head.content_length = 99;
...@@ -461,14 +395,12 @@ TEST_F(MojoAsyncResourceHandlerTest, OnResponseStarted) { ...@@ -461,14 +395,12 @@ TEST_F(MojoAsyncResourceHandlerTest, OnResponseStarted) {
response->head.response_start = response->head.response_start =
base::TimeTicks::UnixEpoch() + base::TimeDelta::FromDays(28); base::TimeTicks::UnixEpoch() + base::TimeDelta::FromDays(28);
bool defer = false;
EXPECT_EQ(0, rdh_delegate_.num_on_response_started_calls()); EXPECT_EQ(0, rdh_delegate_.num_on_response_started_calls());
base::TimeTicks now1 = base::TimeTicks::Now(); base::TimeTicks now1 = base::TimeTicks::Now();
ASSERT_TRUE(handler_->OnResponseStarted(response.get(), &defer)); ASSERT_EQ(MockResourceLoader::Status::IDLE,
mock_loader_->OnResponseStarted(response));
base::TimeTicks now2 = base::TimeTicks::Now(); base::TimeTicks now2 = base::TimeTicks::Now();
EXPECT_FALSE(defer);
EXPECT_EQ(request_->creation_time(), response->head.request_start); EXPECT_EQ(request_->creation_time(), response->head.request_start);
EXPECT_LE(now1, response->head.response_start); EXPECT_LE(now1, response->head.response_start);
EXPECT_LE(response->head.response_start, now2); EXPECT_LE(response->head.response_start, now2);
...@@ -485,9 +417,7 @@ TEST_F(MojoAsyncResourceHandlerTest, OnResponseStarted) { ...@@ -485,9 +417,7 @@ TEST_F(MojoAsyncResourceHandlerTest, OnResponseStarted) {
TEST_F(MojoAsyncResourceHandlerTest, OnWillReadAndInFlightRequests) { TEST_F(MojoAsyncResourceHandlerTest, OnWillReadAndInFlightRequests) {
ASSERT_TRUE(CallOnWillStartAndOnResponseStarted()); ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
EXPECT_EQ(0, rdh_.num_in_flight_requests_for_testing()); EXPECT_EQ(0, rdh_.num_in_flight_requests_for_testing());
scoped_refptr<net::IOBuffer> io_buffer; ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
int io_buffer_size = 0;
EXPECT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
EXPECT_EQ(1, rdh_.num_in_flight_requests_for_testing()); EXPECT_EQ(1, rdh_.num_in_flight_requests_for_testing());
handler_ = nullptr; handler_ = nullptr;
EXPECT_EQ(0, rdh_.num_in_flight_requests_for_testing()); EXPECT_EQ(0, rdh_.num_in_flight_requests_for_testing());
...@@ -497,36 +427,25 @@ TEST_F(MojoAsyncResourceHandlerTest, OnWillReadWithInsufficientResource) { ...@@ -497,36 +427,25 @@ TEST_F(MojoAsyncResourceHandlerTest, OnWillReadWithInsufficientResource) {
rdh_.set_max_num_in_flight_requests_per_process(0); rdh_.set_max_num_in_flight_requests_per_process(0);
ASSERT_TRUE(CallOnWillStartAndOnResponseStarted()); ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
scoped_refptr<net::IOBuffer> io_buffer; ASSERT_EQ(MockResourceLoader::Status::CANCELED, mock_loader_->OnWillRead(-1));
int io_buffer_size = 0; EXPECT_EQ(net::ERR_INSUFFICIENT_RESOURCES, mock_loader_->error_code());
EXPECT_FALSE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
EXPECT_FALSE(io_buffer);
EXPECT_EQ(0, io_buffer_size);
EXPECT_EQ(1, rdh_.num_in_flight_requests_for_testing()); EXPECT_EQ(1, rdh_.num_in_flight_requests_for_testing());
EXPECT_TRUE(resource_controller_.is_cancel_with_error_called());
EXPECT_EQ(net::ERR_INSUFFICIENT_RESOURCES, resource_controller_.error());
handler_ = nullptr; handler_ = nullptr;
EXPECT_EQ(0, rdh_.num_in_flight_requests_for_testing()); EXPECT_EQ(0, rdh_.num_in_flight_requests_for_testing());
} }
TEST_F(MojoAsyncResourceHandlerTest, OnWillReadAndOnReadCompleted) { TEST_F(MojoAsyncResourceHandlerTest, OnWillReadAndOnReadCompleted) {
bool defer = false;
scoped_refptr<net::IOBuffer> io_buffer;
int io_buffer_size = 0;
ASSERT_TRUE(CallOnWillStartAndOnResponseStarted()); ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1)); ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
ASSERT_TRUE(io_buffer);
// The buffer size that the mime sniffer requires implicitly. // The buffer size that the mime sniffer requires implicitly.
ASSERT_GE(io_buffer_size, kSizeMimeSnifferRequiresForFirstOnWillRead); ASSERT_GE(mock_loader_->io_buffer_size(),
kSizeMimeSnifferRequiresForFirstOnWillRead);
url_loader_client_.RunUntilResponseBodyArrived(); url_loader_client_.RunUntilResponseBodyArrived();
ASSERT_TRUE(url_loader_client_.response_body().is_valid()); ASSERT_TRUE(url_loader_client_.response_body().is_valid());
io_buffer->data()[0] = 'A'; ASSERT_EQ(MockResourceLoader::Status::IDLE,
io_buffer->data()[1] = 'B'; mock_loader_->OnReadCompleted("AB"));
ASSERT_TRUE(handler_->OnReadCompleted(2, &defer));
EXPECT_FALSE(defer);
std::string contents; std::string contents;
while (contents.size() < 2) { while (contents.size() < 2) {
...@@ -548,23 +467,18 @@ TEST_F(MojoAsyncResourceHandlerTest, ...@@ -548,23 +467,18 @@ TEST_F(MojoAsyncResourceHandlerTest,
OnWillReadAndOnReadCompletedWithInsufficientInitialCapacity) { OnWillReadAndOnReadCompletedWithInsufficientInitialCapacity) {
MojoAsyncResourceHandler::SetAllocationSizeForTesting(2); MojoAsyncResourceHandler::SetAllocationSizeForTesting(2);
bool defer = false;
scoped_refptr<net::IOBuffer> io_buffer;
int io_buffer_size = 0;
ASSERT_TRUE(CallOnWillStartAndOnResponseStarted()); ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1)); ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
ASSERT_TRUE(io_buffer);
// The buffer size that the mime sniffer requires implicitly. // The buffer size that the mime sniffer requires implicitly.
ASSERT_GE(io_buffer_size, kSizeMimeSnifferRequiresForFirstOnWillRead); ASSERT_GE(mock_loader_->io_buffer_size(),
kSizeMimeSnifferRequiresForFirstOnWillRead);
url_loader_client_.RunUntilResponseBodyArrived(); url_loader_client_.RunUntilResponseBodyArrived();
ASSERT_TRUE(url_loader_client_.response_body().is_valid()); ASSERT_TRUE(url_loader_client_.response_body().is_valid());
const std::string data("abcdefgh"); const std::string data("abcdefgh");
strcpy(io_buffer->data(), data.c_str()); ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
ASSERT_TRUE(handler_->OnReadCompleted(data.size(), &defer)); mock_loader_->OnReadCompleted(data));
EXPECT_TRUE(defer);
std::string contents; std::string contents;
while (contents.size() < data.size()) { while (contents.size() < data.size()) {
...@@ -581,30 +495,27 @@ TEST_F(MojoAsyncResourceHandlerTest, ...@@ -581,30 +495,27 @@ TEST_F(MojoAsyncResourceHandlerTest,
contents.append(buffer, read_size); contents.append(buffer, read_size);
} }
EXPECT_EQ(data, contents); EXPECT_EQ(data, contents);
EXPECT_EQ(0, resource_controller_.num_resume_calls()); EXPECT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
mock_loader_->status());
} }
TEST_F(MojoAsyncResourceHandlerTest, TEST_F(MojoAsyncResourceHandlerTest,
IOBufferFromOnWillReadShouldRemainValidEvenIfHandlerIsGone) { IOBufferFromOnWillReadShouldRemainValidEvenIfHandlerIsGone) {
scoped_refptr<net::IOBuffer> io_buffer;
int io_buffer_size = 0;
ASSERT_TRUE(CallOnWillStartAndOnResponseStarted()); ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1)); ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
ASSERT_TRUE(io_buffer);
// The io_buffer size that the mime sniffer requires implicitly. // The io_buffer size that the mime sniffer requires implicitly.
ASSERT_GE(io_buffer_size, kSizeMimeSnifferRequiresForFirstOnWillRead); ASSERT_GE(mock_loader_->io_buffer_size(),
kSizeMimeSnifferRequiresForFirstOnWillRead);
handler_ = nullptr; handler_ = nullptr;
url_loader_client_.Unbind(); url_loader_client_.Unbind();
base::RunLoop().RunUntilIdle(); base::RunLoop().RunUntilIdle();
// Hopefully ASAN checks this operation's validity. // Hopefully ASAN checks this operation's validity.
io_buffer->data()[0] = 'A'; mock_loader_->io_buffer()->data()[0] = 'A';
} }
TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompleted) { TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompleted) {
bool defer = false;
ASSERT_TRUE(CallOnWillStartAndOnResponseStarted()); ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
ResourceRequestInfoImpl::ForRequest(request_.get()) ResourceRequestInfoImpl::ForRequest(request_.get())
...@@ -612,9 +523,9 @@ TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompleted) { ...@@ -612,9 +523,9 @@ TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompleted) {
net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, net::OK); net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, net::OK);
base::TimeTicks now1 = base::TimeTicks::Now(); base::TimeTicks now1 = base::TimeTicks::Now();
handler_->OnResponseCompleted(status, &defer); ASSERT_EQ(MockResourceLoader::Status::IDLE,
mock_loader_->OnResponseCompleted(status));
base::TimeTicks now2 = base::TimeTicks::Now(); base::TimeTicks now2 = base::TimeTicks::Now();
EXPECT_FALSE(defer);
url_loader_client_.RunUntilComplete(); url_loader_client_.RunUntilComplete();
EXPECT_TRUE(url_loader_client_.has_received_completion()); EXPECT_TRUE(url_loader_client_.has_received_completion());
...@@ -629,13 +540,13 @@ TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompleted) { ...@@ -629,13 +540,13 @@ TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompleted) {
// This test case sets different status values from OnResponseCompleted. // This test case sets different status values from OnResponseCompleted.
TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompleted2) { TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompleted2) {
rdh_.SetDelegate(nullptr); rdh_.SetDelegate(nullptr);
bool defer = false;
// Don't use CallOnWillStartAndOnResponseStarted as this test case manually // Don't use CallOnWillStartAndOnResponseStarted as this test case manually
// sets the null delegate. // sets the null delegate.
ASSERT_TRUE(CallOnWillStart()); ASSERT_EQ(MockResourceLoader::Status::IDLE,
scoped_refptr<ResourceResponse> response = new ResourceResponse(); mock_loader_->OnWillStart(request_->url()));
ASSERT_TRUE(handler_->OnResponseStarted(response.get(), &defer)); ASSERT_EQ(MockResourceLoader::Status::IDLE,
ASSERT_FALSE(defer); mock_loader_->OnResponseStarted(
make_scoped_refptr(new ResourceResponse())));
ASSERT_FALSE(url_loader_client_.has_received_response()); ASSERT_FALSE(url_loader_client_.has_received_response());
url_loader_client_.RunUntilResponseReceived(); url_loader_client_.RunUntilResponseReceived();
...@@ -645,9 +556,9 @@ TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompleted2) { ...@@ -645,9 +556,9 @@ TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompleted2) {
net::ERR_ABORTED); net::ERR_ABORTED);
base::TimeTicks now1 = base::TimeTicks::Now(); base::TimeTicks now1 = base::TimeTicks::Now();
handler_->OnResponseCompleted(status, &defer); ASSERT_EQ(MockResourceLoader::Status::IDLE,
mock_loader_->OnResponseCompleted(status));
base::TimeTicks now2 = base::TimeTicks::Now(); base::TimeTicks now2 = base::TimeTicks::Now();
EXPECT_FALSE(defer);
url_loader_client_.RunUntilComplete(); url_loader_client_.RunUntilComplete();
EXPECT_TRUE(url_loader_client_.has_received_completion()); EXPECT_TRUE(url_loader_client_.has_received_completion());
...@@ -663,11 +574,10 @@ TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompleted2) { ...@@ -663,11 +574,10 @@ TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompleted2) {
TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompletedWithCanceledTimedOut) { TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompletedWithCanceledTimedOut) {
net::URLRequestStatus status(net::URLRequestStatus::CANCELED, net::URLRequestStatus status(net::URLRequestStatus::CANCELED,
net::ERR_TIMED_OUT); net::ERR_TIMED_OUT);
bool defer = false;
ASSERT_TRUE(CallOnWillStartAndOnResponseStarted()); ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
handler_->OnResponseCompleted(status, &defer); ASSERT_EQ(MockResourceLoader::Status::IDLE,
EXPECT_FALSE(defer); mock_loader_->OnResponseCompleted(status));
url_loader_client_.RunUntilComplete(); url_loader_client_.RunUntilComplete();
EXPECT_TRUE(url_loader_client_.has_received_completion()); EXPECT_TRUE(url_loader_client_.has_received_completion());
...@@ -678,11 +588,10 @@ TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompletedWithCanceledTimedOut) { ...@@ -678,11 +588,10 @@ TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompletedWithCanceledTimedOut) {
TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompletedWithFailedTimedOut) { TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompletedWithFailedTimedOut) {
net::URLRequestStatus status(net::URLRequestStatus::FAILED, net::URLRequestStatus status(net::URLRequestStatus::FAILED,
net::ERR_TIMED_OUT); net::ERR_TIMED_OUT);
bool defer = false;
ASSERT_TRUE(CallOnWillStartAndOnResponseStarted()); ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
handler_->OnResponseCompleted(status, &defer); ASSERT_EQ(MockResourceLoader::Status::IDLE,
EXPECT_FALSE(defer); mock_loader_->OnResponseCompleted(status));
url_loader_client_.RunUntilComplete(); url_loader_client_.RunUntilComplete();
EXPECT_TRUE(url_loader_client_.has_received_completion()); EXPECT_TRUE(url_loader_client_.has_received_completion());
...@@ -693,26 +602,19 @@ TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompletedWithFailedTimedOut) { ...@@ -693,26 +602,19 @@ TEST_F(MojoAsyncResourceHandlerTest, OnResponseCompletedWithFailedTimedOut) {
TEST_F(MojoAsyncResourceHandlerTest, ResponseCompletionShouldCloseDataPipe) { TEST_F(MojoAsyncResourceHandlerTest, ResponseCompletionShouldCloseDataPipe) {
ASSERT_TRUE(CallOnWillStartAndOnResponseStarted()); ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
scoped_refptr<net::IOBuffer> io_buffer; ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
int io_buffer_size = 0;
bool defer = false;
ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
url_loader_client_.RunUntilResponseBodyArrived(); url_loader_client_.RunUntilResponseBodyArrived();
ASSERT_TRUE(url_loader_client_.response_body().is_valid()); ASSERT_TRUE(url_loader_client_.response_body().is_valid());
ASSERT_TRUE(handler_->OnReadCompleted(0, &defer)); ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnReadCompleted(0));
EXPECT_FALSE(defer);
net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, net::OK); net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, net::OK);
handler_->OnResponseCompleted(status, &defer); ASSERT_EQ(MockResourceLoader::Status::IDLE,
EXPECT_FALSE(defer); mock_loader_->OnResponseCompleted(status));
url_loader_client_.RunUntilComplete(); url_loader_client_.RunUntilComplete();
EXPECT_TRUE(url_loader_client_.has_received_completion()); EXPECT_TRUE(url_loader_client_.has_received_completion());
EXPECT_EQ(net::OK, url_loader_client_.completion_status().error_code); EXPECT_EQ(net::OK, url_loader_client_.completion_status().error_code);
// This is needed because |*io_buffer| may keep the data producer alive.
io_buffer = nullptr;
while (true) { while (true) {
char buffer[16]; char buffer[16];
uint32_t read_size = sizeof(buffer); uint32_t read_size = sizeof(buffer);
...@@ -725,32 +627,25 @@ TEST_F(MojoAsyncResourceHandlerTest, ResponseCompletionShouldCloseDataPipe) { ...@@ -725,32 +627,25 @@ TEST_F(MojoAsyncResourceHandlerTest, ResponseCompletionShouldCloseDataPipe) {
} }
} }
TEST_F(MojoAsyncResourceHandlerTest, ResponseErrorDuringBodyTransmission) { TEST_F(MojoAsyncResourceHandlerTest, OutOfBandCancelDuringBodyTransmission) {
ASSERT_TRUE(CallOnWillStartAndOnResponseStarted()); ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
scoped_refptr<net::IOBuffer> io_buffer; ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
int io_buffer_size = 0;
ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
url_loader_client_.RunUntilResponseBodyArrived(); url_loader_client_.RunUntilResponseBodyArrived();
ASSERT_TRUE(url_loader_client_.response_body().is_valid()); ASSERT_TRUE(url_loader_client_.response_body().is_valid());
ASSERT_GT(io_buffer_size, 0); std::string data(mock_loader_->io_buffer_size(), 'a');
memset(io_buffer->data(), 'a', io_buffer_size); ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
bool defer = false; mock_loader_->OnReadCompleted(data));
ASSERT_TRUE(handler_->OnReadCompleted(io_buffer_size, &defer));
// We don't care |defer|'s value here.
defer = false;
net::URLRequestStatus status(net::URLRequestStatus::FAILED, net::ERR_FAILED); net::URLRequestStatus status(net::URLRequestStatus::FAILED, net::ERR_FAILED);
handler_->OnResponseCompleted(status, &defer); ASSERT_EQ(
EXPECT_FALSE(defer); MockResourceLoader::Status::IDLE,
mock_loader_->OnResponseCompletedFromExternalOutOfBandCancel(status));
url_loader_client_.RunUntilComplete(); url_loader_client_.RunUntilComplete();
EXPECT_TRUE(url_loader_client_.has_received_completion()); EXPECT_TRUE(url_loader_client_.has_received_completion());
EXPECT_EQ(net::ERR_FAILED, url_loader_client_.completion_status().error_code); EXPECT_EQ(net::ERR_FAILED, url_loader_client_.completion_status().error_code);
// This is needed because |*io_buffer| may keep the data producer alive.
io_buffer = nullptr;
std::string actual; std::string actual;
while (true) { while (true) {
char buf[16]; char buf[16];
...@@ -767,30 +662,24 @@ TEST_F(MojoAsyncResourceHandlerTest, ResponseErrorDuringBodyTransmission) { ...@@ -767,30 +662,24 @@ TEST_F(MojoAsyncResourceHandlerTest, ResponseErrorDuringBodyTransmission) {
EXPECT_EQ(MOJO_RESULT_OK, result); EXPECT_EQ(MOJO_RESULT_OK, result);
actual.append(buf, read_size); actual.append(buf, read_size);
} }
EXPECT_EQ(std::string(io_buffer_size, 'a'), actual); EXPECT_EQ(data, actual);
} }
// In this case, an error is notified after OnWillRead, before OnReadCompleted. // In this case, an error is notified after OnWillRead, before OnReadCompleted.
TEST_F(MojoAsyncResourceHandlerTest, ResponseErrorDuringBodyTransmission2) { TEST_F(MojoAsyncResourceHandlerTest, ResponseErrorDuringBodyTransmission2) {
ASSERT_TRUE(CallOnWillStartAndOnResponseStarted()); ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
scoped_refptr<net::IOBuffer> io_buffer; ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
int io_buffer_size = 0;
ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
url_loader_client_.RunUntilResponseBodyArrived(); url_loader_client_.RunUntilResponseBodyArrived();
ASSERT_TRUE(url_loader_client_.response_body().is_valid()); ASSERT_TRUE(url_loader_client_.response_body().is_valid());
bool defer = false;
net::URLRequestStatus status(net::URLRequestStatus::FAILED, net::ERR_FAILED); net::URLRequestStatus status(net::URLRequestStatus::FAILED, net::ERR_FAILED);
handler_->OnResponseCompleted(status, &defer); ASSERT_EQ(MockResourceLoader::Status::IDLE,
EXPECT_FALSE(defer); mock_loader_->OnResponseCompleted(status));
url_loader_client_.RunUntilComplete(); url_loader_client_.RunUntilComplete();
EXPECT_TRUE(url_loader_client_.has_received_completion()); EXPECT_TRUE(url_loader_client_.has_received_completion());
EXPECT_EQ(net::ERR_FAILED, url_loader_client_.completion_status().error_code); EXPECT_EQ(net::ERR_FAILED, url_loader_client_.completion_status().error_code);
// This is needed because |*io_buffer| may keep the data producer alive.
io_buffer = nullptr;
while (true) { while (true) {
char buf[16]; char buf[16];
uint32_t read_size = sizeof(buf); uint32_t read_size = sizeof(buf);
...@@ -806,21 +695,14 @@ TEST_F(MojoAsyncResourceHandlerTest, ResponseErrorDuringBodyTransmission2) { ...@@ -806,21 +695,14 @@ TEST_F(MojoAsyncResourceHandlerTest, ResponseErrorDuringBodyTransmission2) {
TEST_F(MojoAsyncResourceHandlerTest, BeginWriteFailsOnWillRead) { TEST_F(MojoAsyncResourceHandlerTest, BeginWriteFailsOnWillRead) {
handler_->set_begin_write_expectation(MOJO_RESULT_UNKNOWN); handler_->set_begin_write_expectation(MOJO_RESULT_UNKNOWN);
scoped_refptr<net::IOBuffer> io_buffer;
int io_buffer_size = 0;
ASSERT_TRUE(CallOnWillStartAndOnResponseStarted()); ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
ASSERT_FALSE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1)); ASSERT_EQ(MockResourceLoader::Status::CANCELED, mock_loader_->OnWillRead(-1));
EXPECT_FALSE(resource_controller_.is_cancel_with_error_called());
} }
TEST_F(MojoAsyncResourceHandlerTest, BeginWriteReturnsShouldWaitOnWillRead) { TEST_F(MojoAsyncResourceHandlerTest, BeginWriteReturnsShouldWaitOnWillRead) {
handler_->set_begin_write_expectation(MOJO_RESULT_SHOULD_WAIT); handler_->set_begin_write_expectation(MOJO_RESULT_SHOULD_WAIT);
scoped_refptr<net::IOBuffer> io_buffer;
int io_buffer_size = 0;
ASSERT_TRUE(CallOnWillStartAndOnResponseStarted()); ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1)); ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
EXPECT_TRUE(io_buffer);
EXPECT_GT(io_buffer_size, 0);
} }
TEST_F(MojoAsyncResourceHandlerTest, TEST_F(MojoAsyncResourceHandlerTest,
...@@ -829,17 +711,13 @@ TEST_F(MojoAsyncResourceHandlerTest, ...@@ -829,17 +711,13 @@ TEST_F(MojoAsyncResourceHandlerTest,
ASSERT_TRUE(CallOnWillStartAndOnResponseStarted()); ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
size_t written = 0; size_t written = 0;
while (true) { while (true) {
scoped_refptr<net::IOBuffer> io_buffer; ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
int io_buffer_size = 0; MockResourceLoader::Status result = mock_loader_->OnReadCompleted(
ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1)); std::string(mock_loader_->io_buffer_size(), 'X'));
EXPECT_TRUE(io_buffer); written += mock_loader_->io_buffer_size();
EXPECT_GT(io_buffer_size, 0); if (result == MockResourceLoader::Status::CALLBACK_PENDING)
memset(io_buffer->data(), 'X', io_buffer_size);
written += io_buffer_size;
bool defer = false;
ASSERT_TRUE(handler_->OnReadCompleted(io_buffer_size, &defer));
if (defer)
break; break;
ASSERT_EQ(MockResourceLoader::Status::IDLE, result);
} }
url_loader_client_.RunUntilResponseBodyArrived(); url_loader_client_.RunUntilResponseBodyArrived();
...@@ -861,7 +739,7 @@ TEST_F(MojoAsyncResourceHandlerTest, ...@@ -861,7 +739,7 @@ TEST_F(MojoAsyncResourceHandlerTest,
} }
EXPECT_EQ(std::string(written, 'X'), actual); EXPECT_EQ(std::string(written, 'X'), actual);
EXPECT_EQ(1, resource_controller_.num_resume_calls()); EXPECT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->status());
} }
TEST_F(MojoAsyncResourceHandlerTest, TEST_F(MojoAsyncResourceHandlerTest,
...@@ -869,52 +747,47 @@ TEST_F(MojoAsyncResourceHandlerTest, ...@@ -869,52 +747,47 @@ TEST_F(MojoAsyncResourceHandlerTest,
MojoAsyncResourceHandler::SetAllocationSizeForTesting(2); MojoAsyncResourceHandler::SetAllocationSizeForTesting(2);
ASSERT_TRUE(CallOnWillStartAndOnResponseStarted()); ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
handler_->set_end_write_expectation(MOJO_RESULT_UNKNOWN); handler_->set_end_write_expectation(MOJO_RESULT_UNKNOWN);
scoped_refptr<net::IOBuffer> io_buffer; ASSERT_EQ(MockResourceLoader::Status::CANCELED, mock_loader_->OnWillRead(-1));
int io_buffer_size = 0;
ASSERT_FALSE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
} }
TEST_F(MojoAsyncResourceHandlerTest, EndWriteFailsOnReadCompleted) { TEST_F(MojoAsyncResourceHandlerTest, EndWriteFailsOnReadCompleted) {
scoped_refptr<net::IOBuffer> io_buffer;
int io_buffer_size = 0;
bool defer = false;
ASSERT_TRUE(CallOnWillStartAndOnResponseStarted()); ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1)); ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
handler_->set_end_write_expectation(MOJO_RESULT_SHOULD_WAIT); handler_->set_end_write_expectation(MOJO_RESULT_SHOULD_WAIT);
ASSERT_FALSE(handler_->OnReadCompleted(io_buffer_size, &defer)); ASSERT_EQ(MockResourceLoader::Status::CANCELED,
mock_loader_->OnReadCompleted(
std::string(mock_loader_->io_buffer_size(), 'w')));
} }
TEST_F(MojoAsyncResourceHandlerTest, TEST_F(MojoAsyncResourceHandlerTest,
EndWriteFailsOnReadCompletedWithInsufficientInitialCapacity) { EndWriteFailsOnReadCompletedWithInsufficientInitialCapacity) {
MojoAsyncResourceHandler::SetAllocationSizeForTesting(2); MojoAsyncResourceHandler::SetAllocationSizeForTesting(2);
scoped_refptr<net::IOBuffer> io_buffer;
int io_buffer_size = 0;
bool defer = false;
ASSERT_TRUE(CallOnWillStartAndOnResponseStarted()); ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1)); ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
handler_->set_end_write_expectation(MOJO_RESULT_SHOULD_WAIT); handler_->set_end_write_expectation(MOJO_RESULT_SHOULD_WAIT);
ASSERT_FALSE(handler_->OnReadCompleted(io_buffer_size, &defer)); ASSERT_EQ(MockResourceLoader::Status::CANCELED,
mock_loader_->OnReadCompleted(
std::string(mock_loader_->io_buffer_size(), 'w')));
} }
TEST_F(MojoAsyncResourceHandlerTest, TEST_F(MojoAsyncResourceHandlerTest,
EndWriteFailsOnResumeWithInsufficientInitialCapacity) { EndWriteFailsOnResumeWithInsufficientInitialCapacity) {
MojoAsyncResourceHandler::SetAllocationSizeForTesting(8); MojoAsyncResourceHandler::SetAllocationSizeForTesting(8);
ASSERT_TRUE(CallOnWillStartAndOnResponseStarted()); ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
scoped_refptr<net::IOBuffer> io_buffer; ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
int io_buffer_size = 0;
ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
url_loader_client_.RunUntilResponseBodyArrived(); url_loader_client_.RunUntilResponseBodyArrived();
ASSERT_TRUE(url_loader_client_.response_body().is_valid()); ASSERT_TRUE(url_loader_client_.response_body().is_valid());
while (true) { while (true) {
bool defer = false; MockResourceLoader::Status result = mock_loader_->OnReadCompleted(
ASSERT_TRUE(handler_->OnReadCompleted(io_buffer_size, &defer)); std::string(mock_loader_->io_buffer_size(), 'A'));
ASSERT_GE(io_buffer_size, 0); if (result == MockResourceLoader::Status::CALLBACK_PENDING)
if (defer)
break; break;
ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1)); ASSERT_EQ(MockResourceLoader::Status::IDLE, result);
ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
} }
while (true) { while (true) {
...@@ -929,29 +802,21 @@ TEST_F(MojoAsyncResourceHandlerTest, ...@@ -929,29 +802,21 @@ TEST_F(MojoAsyncResourceHandlerTest,
} }
handler_->set_end_write_expectation(MOJO_RESULT_SHOULD_WAIT); handler_->set_end_write_expectation(MOJO_RESULT_SHOULD_WAIT);
resource_controller_.RunUntilCancelWithErrorCalled(); mock_loader_->WaitUntilIdleOrCanceled();
EXPECT_FALSE(url_loader_client_.has_received_completion()); EXPECT_FALSE(url_loader_client_.has_received_completion());
EXPECT_TRUE(resource_controller_.is_cancel_with_error_called()); EXPECT_EQ(MockResourceLoader::Status::CANCELED, mock_loader_->status());
EXPECT_EQ(net::ERR_FAILED, resource_controller_.error()); EXPECT_EQ(net::ERR_FAILED, mock_loader_->error_code());
} }
TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest, TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest,
OnWillReadWithLongContents) { OnWillReadWithLongContents) {
bool defer = false;
scoped_refptr<net::IOBuffer> io_buffer;
int io_buffer_size = 0;
ASSERT_TRUE(CallOnWillStartAndOnResponseStarted()); ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1)); ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
ASSERT_TRUE(io_buffer);
// The io_buffer size that the mime sniffer requires implicitly.
ASSERT_GE(io_buffer_size, kSizeMimeSnifferRequiresForFirstOnWillRead);
std::string expected; std::string expected;
for (int i = 0; i < 3 * io_buffer_size + 2; ++i) for (int i = 0; i < 3 * mock_loader_->io_buffer_size() + 2; ++i)
expected += ('A' + i % 26); expected += ('A' + i % 26);
ASSERT_TRUE(handler_->OnReadCompleted(0, &defer)); ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnReadCompleted(0));
ASSERT_FALSE(defer);
url_loader_client_.RunUntilResponseBodyArrived(); url_loader_client_.RunUntilResponseBodyArrived();
ASSERT_TRUE(url_loader_client_.response_body().is_valid()); ASSERT_TRUE(url_loader_client_.response_body().is_valid());
...@@ -959,12 +824,18 @@ TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest, ...@@ -959,12 +824,18 @@ TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest,
size_t written = 0; size_t written = 0;
std::string actual; std::string actual;
while (actual.size() < expected.size()) { while (actual.size() < expected.size()) {
while (written < expected.size() && !defer) { while (written < expected.size() &&
ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1)); mock_loader_->status() == MockResourceLoader::Status::IDLE) {
const size_t to_be_written = std::min(static_cast<size_t>(io_buffer_size), ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
const size_t to_be_written =
std::min(static_cast<size_t>(mock_loader_->io_buffer_size()),
expected.size() - written); expected.size() - written);
memcpy(io_buffer->data(), &expected[written], to_be_written);
ASSERT_TRUE(handler_->OnReadCompleted(to_be_written, &defer)); // Request should be resumed or paused.
ASSERT_NE(MockResourceLoader::Status::CANCELED,
mock_loader_->OnReadCompleted(
expected.substr(written, to_be_written)));
written += to_be_written; written += to_be_written;
} }
...@@ -977,59 +848,55 @@ TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest, ...@@ -977,59 +848,55 @@ TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest,
ASSERT_EQ(MOJO_RESULT_OK, result); ASSERT_EQ(MOJO_RESULT_OK, result);
actual.append(buf, read_size); actual.append(buf, read_size);
} }
int resume_count = resource_controller_.num_resume_calls();
// Give mojo a chance pass data back and forth, and to request more data
// from the handler.
base::RunLoop().RunUntilIdle(); base::RunLoop().RunUntilIdle();
// Continue writing if controller->Resume() is called.
defer = (resume_count == resource_controller_.num_resume_calls());
} }
EXPECT_EQ(expected, actual); EXPECT_EQ(expected, actual);
} }
TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest, TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest,
BeginWriteFailsOnReadCompleted) { BeginWriteFailsOnReadCompleted) {
scoped_refptr<net::IOBuffer> io_buffer;
int io_buffer_size = 0;
bool defer = false;
ASSERT_TRUE(CallOnWillStartAndOnResponseStarted()); ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1)); ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
handler_->set_begin_write_expectation(MOJO_RESULT_UNKNOWN); handler_->set_begin_write_expectation(MOJO_RESULT_UNKNOWN);
ASSERT_FALSE(handler_->OnReadCompleted(io_buffer_size, &defer)); ASSERT_EQ(MockResourceLoader::Status::CANCELED,
mock_loader_->OnReadCompleted(
std::string(mock_loader_->io_buffer_size(), 'A')));
} }
TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest, TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest,
BeginWriteReturnsShouldWaitOnReadCompleted) { BeginWriteReturnsShouldWaitOnReadCompleted) {
scoped_refptr<net::IOBuffer> io_buffer;
int io_buffer_size = 0;
bool defer = false;
ASSERT_TRUE(CallOnWillStartAndOnResponseStarted()); ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1)); ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
handler_->set_begin_write_expectation(MOJO_RESULT_SHOULD_WAIT); handler_->set_begin_write_expectation(MOJO_RESULT_SHOULD_WAIT);
ASSERT_TRUE(handler_->OnReadCompleted(io_buffer_size, &defer)); ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
EXPECT_TRUE(defer); mock_loader_->OnReadCompleted(
std::string(mock_loader_->io_buffer_size(), 'A')));
} }
TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest, TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest,
BeginWriteFailsOnResume) { BeginWriteFailsOnResume) {
bool defer = false;
int io_buffer_size = 0;
scoped_refptr<net::IOBuffer> io_buffer;
ASSERT_TRUE(CallOnWillStartAndOnResponseStarted()); ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1)); ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
ASSERT_TRUE(handler_->OnReadCompleted(0, &defer)); ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnReadCompleted(0));
ASSERT_FALSE(defer);
url_loader_client_.RunUntilResponseBodyArrived(); url_loader_client_.RunUntilResponseBodyArrived();
ASSERT_TRUE(url_loader_client_.response_body().is_valid()); ASSERT_TRUE(url_loader_client_.response_body().is_valid());
while (!defer) { while (true) {
ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1)); ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
ASSERT_TRUE(handler_->OnReadCompleted(io_buffer_size, &defer)); MockResourceLoader::Status result = mock_loader_->OnReadCompleted(
std::string(mock_loader_->io_buffer_size(), 'A'));
if (result == MockResourceLoader::Status::CALLBACK_PENDING)
break;
ASSERT_EQ(MockResourceLoader::Status::IDLE, result);
} }
handler_->set_begin_write_expectation(MOJO_RESULT_UNKNOWN); handler_->set_begin_write_expectation(MOJO_RESULT_UNKNOWN);
while (!resource_controller_.is_cancel_with_error_called()) { while (mock_loader_->status() != MockResourceLoader::Status::CANCELED) {
char buf[256]; char buf[256];
uint32_t read_size = sizeof(buf); uint32_t read_size = sizeof(buf);
MojoResult result = MojoResult result =
...@@ -1040,28 +907,29 @@ TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest, ...@@ -1040,28 +907,29 @@ TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest,
} }
EXPECT_FALSE(url_loader_client_.has_received_completion()); EXPECT_FALSE(url_loader_client_.has_received_completion());
EXPECT_EQ(net::ERR_FAILED, resource_controller_.error()); EXPECT_EQ(net::ERR_FAILED, mock_loader_->error_code());
EXPECT_EQ(0, resource_controller_.num_resume_calls());
} }
TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest, CancelWhileWaiting) { TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest, CancelWhileWaiting) {
bool defer = false;
ASSERT_TRUE(CallOnWillStartAndOnResponseStarted()); ASSERT_TRUE(CallOnWillStartAndOnResponseStarted());
while (!defer) { while (true) {
scoped_refptr<net::IOBuffer> io_buffer; ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
int io_buffer_size = 0; MockResourceLoader::Status result = mock_loader_->OnReadCompleted(
ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1)); std::string(mock_loader_->io_buffer_size(), 'A'));
ASSERT_TRUE(handler_->OnReadCompleted(io_buffer_size, &defer)); if (result == MockResourceLoader::Status::CALLBACK_PENDING)
break;
ASSERT_EQ(MockResourceLoader::Status::IDLE, result);
} }
url_loader_client_.RunUntilResponseBodyArrived(); url_loader_client_.RunUntilResponseBodyArrived();
ASSERT_TRUE(url_loader_client_.response_body().is_valid()); ASSERT_TRUE(url_loader_client_.response_body().is_valid());
defer = false;
net::URLRequestStatus status(net::URLRequestStatus::CANCELED, net::URLRequestStatus status(net::URLRequestStatus::CANCELED,
net::ERR_ABORTED); net::ERR_ABORTED);
handler_->OnResponseCompleted(status, &defer); ASSERT_EQ(
MockResourceLoader::Status::IDLE,
mock_loader_->OnResponseCompletedFromExternalOutOfBandCancel(status));
ASSERT_FALSE(url_loader_client_.has_received_completion()); ASSERT_FALSE(url_loader_client_.has_received_completion());
url_loader_client_.RunUntilComplete(); url_loader_client_.RunUntilComplete();
...@@ -1081,21 +949,19 @@ TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest, CancelWhileWaiting) { ...@@ -1081,21 +949,19 @@ TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest, CancelWhileWaiting) {
} }
base::RunLoop().RunUntilIdle(); base::RunLoop().RunUntilIdle();
EXPECT_EQ(0, resource_controller_.num_resume_calls());
} }
TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest, RedirectHandling) { TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest, RedirectHandling) {
rdh_delegate_.set_num_on_response_started_calls_expectation(1); rdh_delegate_.set_num_on_response_started_calls_expectation(1);
bool defer = false;
ASSERT_TRUE(handler_->OnWillStart(request_->url(), &defer)); ASSERT_EQ(MockResourceLoader::Status::IDLE,
ASSERT_FALSE(defer); mock_loader_->OnWillStart(request_->url()));
scoped_refptr<ResourceResponse> response = new ResourceResponse();
net::RedirectInfo redirect_info; net::RedirectInfo redirect_info;
redirect_info.status_code = 301; redirect_info.status_code = 301;
ASSERT_TRUE( ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
handler_->OnRequestRedirected(redirect_info, response.get(), &defer)); mock_loader_->OnRequestRedirected(
ASSERT_TRUE(defer); redirect_info, make_scoped_refptr(new ResourceResponse())));
ASSERT_FALSE(url_loader_client_.has_received_response()); ASSERT_FALSE(url_loader_client_.has_received_response());
ASSERT_FALSE(url_loader_client_.has_received_redirect()); ASSERT_FALSE(url_loader_client_.has_received_redirect());
...@@ -1105,17 +971,17 @@ TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest, RedirectHandling) { ...@@ -1105,17 +971,17 @@ TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest, RedirectHandling) {
ASSERT_TRUE(url_loader_client_.has_received_redirect()); ASSERT_TRUE(url_loader_client_.has_received_redirect());
EXPECT_EQ(301, url_loader_client_.redirect_info().status_code); EXPECT_EQ(301, url_loader_client_.redirect_info().status_code);
EXPECT_EQ(0, resource_controller_.num_resume_calls()); ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
mock_loader_->status());
handler_->FollowRedirect(); handler_->FollowRedirect();
EXPECT_EQ(1, resource_controller_.num_resume_calls()); ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->status());
url_loader_client_.ClearHasReceivedRedirect(); url_loader_client_.ClearHasReceivedRedirect();
// Redirect once more. // Redirect once more.
defer = false;
redirect_info.status_code = 302; redirect_info.status_code = 302;
ASSERT_TRUE( ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
handler_->OnRequestRedirected(redirect_info, response.get(), &defer)); mock_loader_->OnRequestRedirected(
ASSERT_TRUE(defer); redirect_info, make_scoped_refptr(new ResourceResponse())));
ASSERT_FALSE(url_loader_client_.has_received_response()); ASSERT_FALSE(url_loader_client_.has_received_response());
ASSERT_FALSE(url_loader_client_.has_received_redirect()); ASSERT_FALSE(url_loader_client_.has_received_redirect());
...@@ -1125,18 +991,19 @@ TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest, RedirectHandling) { ...@@ -1125,18 +991,19 @@ TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest, RedirectHandling) {
ASSERT_TRUE(url_loader_client_.has_received_redirect()); ASSERT_TRUE(url_loader_client_.has_received_redirect());
EXPECT_EQ(302, url_loader_client_.redirect_info().status_code); EXPECT_EQ(302, url_loader_client_.redirect_info().status_code);
EXPECT_EQ(1, resource_controller_.num_resume_calls()); ASSERT_EQ(MockResourceLoader::Status::CALLBACK_PENDING,
mock_loader_->status());
handler_->FollowRedirect(); handler_->FollowRedirect();
EXPECT_EQ(2, resource_controller_.num_resume_calls()); ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->status());
// Give the final response. // Give the final response.
defer = false; ASSERT_EQ(MockResourceLoader::Status::IDLE,
ASSERT_TRUE(handler_->OnResponseStarted(response.get(), &defer)); mock_loader_->OnResponseStarted(
ASSERT_FALSE(defer); make_scoped_refptr(new ResourceResponse())));
net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, net::OK); net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, net::OK);
handler_->OnResponseCompleted(status, &defer); ASSERT_EQ(MockResourceLoader::Status::IDLE,
ASSERT_FALSE(defer); mock_loader_->OnResponseCompleted(status));
ASSERT_FALSE(url_loader_client_.has_received_completion()); ASSERT_FALSE(url_loader_client_.has_received_completion());
url_loader_client_.RunUntilComplete(); url_loader_client_.RunUntilComplete();
...@@ -1146,12 +1013,13 @@ TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest, RedirectHandling) { ...@@ -1146,12 +1013,13 @@ TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest, RedirectHandling) {
EXPECT_EQ(net::OK, url_loader_client_.completion_status().error_code); EXPECT_EQ(net::OK, url_loader_client_.completion_status().error_code);
} }
// Test the case where th other process tells the ResourceHandler to follow a
// redirect, despite the fact that no redirect has been received yet.
TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest, TEST_P(MojoAsyncResourceHandlerWithAllocationSizeTest,
MalformedFollowRedirectRequest) { MalformedFollowRedirectRequest) {
handler_->FollowRedirect(); handler_->FollowRedirect();
EXPECT_TRUE(handler_->has_received_bad_message()); EXPECT_TRUE(handler_->has_received_bad_message());
EXPECT_EQ(0, resource_controller_.num_resume_calls());
} }
// Typically ResourceHandler methods are called in this order. // Typically ResourceHandler methods are called in this order.
...@@ -1159,41 +1027,32 @@ TEST_P( ...@@ -1159,41 +1027,32 @@ TEST_P(
MojoAsyncResourceHandlerWithAllocationSizeTest, MojoAsyncResourceHandlerWithAllocationSizeTest,
OnWillStartThenOnResponseStartedThenOnWillReadThenOnReadCompletedThenOnResponseCompleted) { OnWillStartThenOnResponseStartedThenOnWillReadThenOnReadCompletedThenOnResponseCompleted) {
rdh_delegate_.set_num_on_response_started_calls_expectation(1); rdh_delegate_.set_num_on_response_started_calls_expectation(1);
bool defer = false;
ASSERT_TRUE(handler_->OnWillStart(request_->url(), &defer)); ASSERT_EQ(MockResourceLoader::Status::IDLE,
ASSERT_FALSE(defer); mock_loader_->OnWillStart(request_->url()));
scoped_refptr<ResourceResponse> response = new ResourceResponse(); ASSERT_EQ(MockResourceLoader::Status::IDLE,
ASSERT_TRUE(handler_->OnResponseStarted(response.get(), &defer)); mock_loader_->OnResponseStarted(
ASSERT_FALSE(defer); make_scoped_refptr(new ResourceResponse())));
ASSERT_FALSE(url_loader_client_.has_received_response()); ASSERT_FALSE(url_loader_client_.has_received_response());
url_loader_client_.RunUntilResponseReceived(); url_loader_client_.RunUntilResponseReceived();
int io_buffer_size = 0; ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
scoped_refptr<net::IOBuffer> io_buffer;
ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
ASSERT_TRUE(io_buffer);
ASSERT_GT(io_buffer_size, 0);
io_buffer->data()[0] = 'A';
ASSERT_FALSE(url_loader_client_.response_body().is_valid()); ASSERT_FALSE(url_loader_client_.response_body().is_valid());
url_loader_client_.RunUntilResponseBodyArrived(); url_loader_client_.RunUntilResponseBodyArrived();
ASSERT_TRUE(url_loader_client_.response_body().is_valid()); ASSERT_TRUE(url_loader_client_.response_body().is_valid());
ASSERT_TRUE(handler_->OnReadCompleted(1, &defer)); ASSERT_EQ(MockResourceLoader::Status::IDLE,
ASSERT_FALSE(defer); mock_loader_->OnReadCompleted("A"));
net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, net::OK); net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, net::OK);
handler_->OnResponseCompleted(status, &defer); ASSERT_EQ(MockResourceLoader::Status::IDLE,
ASSERT_FALSE(defer); mock_loader_->OnResponseCompleted(status));
ASSERT_FALSE(url_loader_client_.has_received_completion()); ASSERT_FALSE(url_loader_client_.has_received_completion());
url_loader_client_.RunUntilComplete(); url_loader_client_.RunUntilComplete();
EXPECT_EQ(net::OK, url_loader_client_.completion_status().error_code); EXPECT_EQ(net::OK, url_loader_client_.completion_status().error_code);
// This is needed because |*io_buffer| may keep the data producer alive.
io_buffer = nullptr;
std::string body; std::string body;
while (true) { while (true) {
char buffer[16]; char buffer[16];
...@@ -1218,42 +1077,33 @@ TEST_P( ...@@ -1218,42 +1077,33 @@ TEST_P(
MojoAsyncResourceHandlerWithAllocationSizeTest, MojoAsyncResourceHandlerWithAllocationSizeTest,
OnWillStartThenOnWillReadThenOnResponseStartedThenOnReadCompletedThenOnResponseCompleted) { OnWillStartThenOnWillReadThenOnResponseStartedThenOnReadCompletedThenOnResponseCompleted) {
rdh_delegate_.set_num_on_response_started_calls_expectation(1); rdh_delegate_.set_num_on_response_started_calls_expectation(1);
bool defer = false;
ASSERT_TRUE(handler_->OnWillStart(request_->url(), &defer)); ASSERT_EQ(MockResourceLoader::Status::IDLE,
ASSERT_FALSE(defer); mock_loader_->OnWillStart(request_->url()));
int io_buffer_size = 0; ASSERT_EQ(MockResourceLoader::Status::IDLE, mock_loader_->OnWillRead(-1));
scoped_refptr<net::IOBuffer> io_buffer;
ASSERT_TRUE(handler_->OnWillRead(&io_buffer, &io_buffer_size, -1));
ASSERT_TRUE(io_buffer);
ASSERT_GT(io_buffer_size, 0);
io_buffer->data()[0] = 'B';
ASSERT_FALSE(url_loader_client_.response_body().is_valid()); ASSERT_FALSE(url_loader_client_.response_body().is_valid());
url_loader_client_.RunUntilResponseBodyArrived(); url_loader_client_.RunUntilResponseBodyArrived();
ASSERT_TRUE(url_loader_client_.response_body().is_valid()); ASSERT_TRUE(url_loader_client_.response_body().is_valid());
scoped_refptr<ResourceResponse> response = new ResourceResponse(); ASSERT_EQ(MockResourceLoader::Status::IDLE,
ASSERT_TRUE(handler_->OnResponseStarted(response.get(), &defer)); mock_loader_->OnResponseStarted(
ASSERT_FALSE(defer); make_scoped_refptr(new ResourceResponse())));
ASSERT_FALSE(url_loader_client_.has_received_response()); ASSERT_FALSE(url_loader_client_.has_received_response());
url_loader_client_.RunUntilResponseReceived(); url_loader_client_.RunUntilResponseReceived();
ASSERT_TRUE(handler_->OnReadCompleted(1, &defer)); ASSERT_EQ(MockResourceLoader::Status::IDLE,
ASSERT_FALSE(defer); mock_loader_->OnReadCompleted("B"));
net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, net::OK); net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, net::OK);
handler_->OnResponseCompleted(status, &defer); ASSERT_EQ(MockResourceLoader::Status::IDLE,
ASSERT_FALSE(defer); mock_loader_->OnResponseCompleted(status));
ASSERT_FALSE(url_loader_client_.has_received_completion()); ASSERT_FALSE(url_loader_client_.has_received_completion());
url_loader_client_.RunUntilComplete(); url_loader_client_.RunUntilComplete();
EXPECT_EQ(net::OK, url_loader_client_.completion_status().error_code); EXPECT_EQ(net::OK, url_loader_client_.completion_status().error_code);
// This is needed because |*io_buffer| may keep the data producer alive.
io_buffer = nullptr;
std::string body; std::string body;
while (true) { while (true) {
char buffer[16]; char buffer[16];
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment