Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(245)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: content/browser/loader/intercepting_resource_handler_unittest.cc

Issue 2476163003: Refactor ResourceHandler API. (Closed)
Patch Set: Minor cleanups, one real fix Created 4 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « content/browser/loader/intercepting_resource_handler.cc ('k') | content/browser/loader/layered_resource_handler.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: content/browser/loader/intercepting_resource_handler_unittest.cc
diff --git a/content/browser/loader/intercepting_resource_handler_unittest.cc b/content/browser/loader/intercepting_resource_handler_unittest.cc
index 9f2096ce76cc344fa15b98a40c0544d459a2b1a0..7d7d66f8dec620489584b72828ec12cd71419072 100644
--- a/content/browser/loader/intercepting_resource_handler_unittest.cc
+++ b/content/browser/loader/intercepting_resource_handler_unittest.cc
@@ -36,15 +36,30 @@ namespace {
class TestResourceController : public ResourceController {
public:
TestResourceController() = default;
- void Cancel() override {}
- void CancelAndIgnore() override {}
- void CancelWithError(int error_code) override {}
+
+ // ResourceController:
+ void Cancel() override { CancelWithError(net::ERR_ABORTED); }
+ void CancelAndIgnore() override { NOTREACHED(); }
+ void CancelWithError(int error_code) override {
+ // It's legal to cancel twise if one request occurs out-of-band, but none of
+ // these tests do that.
+ EXPECT_FALSE(canceled_);
+ EXPECT_LT(error_code, 0);
+ EXPECT_NE(error_code, net::ERR_IO_PENDING);
+ canceled_ = true;
+ error_ = error_code;
+ }
void Resume() override { ++resume_calls_; }
int resume_calls() const { return resume_calls_; }
+ bool canceled() const { return canceled_; }
+ int error() { return error_; }
+
private:
int resume_calls_ = 0;
+ bool canceled_ = false;
+ int error_ = net::OK;
DISALLOW_COPY_AND_ASSIGN(TestResourceController);
};
@@ -88,9 +103,9 @@ TEST_F(InterceptingResourceHandlerTest, NoSwitching) {
// Simulate the MimeSniffingResourceHandler buffering the data.
scoped_refptr<net::IOBuffer> read_buffer;
int buf_size = 0;
- bool defer = false;
- EXPECT_TRUE(intercepting_handler->OnWillStart(GURL(), &defer));
- EXPECT_FALSE(defer);
+ bool defer_or_cancel = false;
+ intercepting_handler->OnWillStart(GURL(), &defer_or_cancel);
+ EXPECT_FALSE(defer_or_cancel);
EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
const std::string kData = "The data";
@@ -101,13 +116,13 @@ TEST_F(InterceptingResourceHandlerTest, NoSwitching) {
memcpy(read_buffer->data(), kData.c_str(), kData.length());
// The response is received. The handler should not change.
- EXPECT_TRUE(intercepting_handler->OnResponseStarted(response.get(), &defer));
- EXPECT_FALSE(defer);
+ intercepting_handler->OnResponseStarted(response.get(), &defer_or_cancel);
+ EXPECT_FALSE(defer_or_cancel);
// The read is replayed by the MimeSniffingResourceHandler. The data should
// have been received by the old intercepting_handler.
- EXPECT_TRUE(intercepting_handler->OnReadCompleted(kData.length(), &defer));
- EXPECT_FALSE(defer);
+ intercepting_handler->OnReadCompleted(kData.length(), &defer_or_cancel);
+ EXPECT_FALSE(defer_or_cancel);
EXPECT_EQ(kData, std::string(old_test_handler->buffer()->data()));
// Make sure another read behave as expected.
@@ -120,8 +135,8 @@ TEST_F(InterceptingResourceHandlerTest, NoSwitching) {
ASSERT_GT(static_cast<size_t>(buf_size), kData2.length());
memcpy(read_buffer->data(), kData2.c_str(), kData2.length());
- EXPECT_TRUE(intercepting_handler->OnReadCompleted(kData2.length(), &defer));
- EXPECT_FALSE(defer);
+ intercepting_handler->OnReadCompleted(kData2.length(), &defer_or_cancel);
+ EXPECT_FALSE(defer_or_cancel);
EXPECT_EQ(kData2, std::string(old_test_handler->buffer()->data()));
EXPECT_EQ(kData + kData2, old_handler_body);
}
@@ -157,9 +172,9 @@ TEST_F(InterceptingResourceHandlerTest, HandlerSwitchNoPayload) {
// Simulate the MimeSniffingResourceHandler buffering the data.
scoped_refptr<net::IOBuffer> read_buffer;
int buf_size = 0;
- bool defer = false;
- EXPECT_TRUE(intercepting_handler->OnWillStart(GURL(), &defer));
- EXPECT_FALSE(defer);
+ bool defer_or_cancel = false;
+ intercepting_handler->OnWillStart(GURL(), &defer_or_cancel);
+ EXPECT_FALSE(defer_or_cancel);
EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
const std::string kData = "The data";
@@ -179,8 +194,8 @@ TEST_F(InterceptingResourceHandlerTest, HandlerSwitchNoPayload) {
// The response is received. The new ResourceHandler should be used handle
// the download.
- EXPECT_TRUE(intercepting_handler->OnResponseStarted(response.get(), &defer));
- EXPECT_FALSE(defer);
+ intercepting_handler->OnResponseStarted(response.get(), &defer_or_cancel);
+ EXPECT_FALSE(defer_or_cancel);
EXPECT_FALSE(old_handler_status.is_success());
EXPECT_EQ(net::ERR_ABORTED, old_handler_status.error());
@@ -191,8 +206,8 @@ TEST_F(InterceptingResourceHandlerTest, HandlerSwitchNoPayload) {
// The read is replayed by the MimeSniffingResourceHandler. The data should
// have been received by the new handler.
- EXPECT_TRUE(intercepting_handler->OnReadCompleted(kData.length(), &defer));
- EXPECT_FALSE(defer);
+ intercepting_handler->OnReadCompleted(kData.length(), &defer_or_cancel);
+ EXPECT_FALSE(defer_or_cancel);
EXPECT_EQ(kData, std::string(new_test_handler->buffer()->data()));
// Make sure another read behaves as expected.
@@ -205,8 +220,8 @@ TEST_F(InterceptingResourceHandlerTest, HandlerSwitchNoPayload) {
EXPECT_NE(kData2, std::string(new_test_handler->buffer()->data()));
memcpy(read_buffer->data(), kData2.c_str(), kData2.length());
- EXPECT_TRUE(intercepting_handler->OnReadCompleted(kData2.length(), &defer));
- EXPECT_FALSE(defer);
+ intercepting_handler->OnReadCompleted(kData2.length(), &defer_or_cancel);
+ EXPECT_FALSE(defer_or_cancel);
EXPECT_EQ(kData2, std::string(new_test_handler->buffer()->data()));
EXPECT_EQ(kData + kData2, new_handler_body);
}
@@ -244,9 +259,9 @@ TEST_F(InterceptingResourceHandlerTest, HandlerSwitchWithPayload) {
// Simulate the MimeSniffingResourceHandler buffering the data.
scoped_refptr<net::IOBuffer> read_buffer;
int buf_size = 0;
- bool defer = false;
- EXPECT_TRUE(intercepting_handler->OnWillStart(GURL(), &defer));
- EXPECT_FALSE(defer);
+ bool defer_or_cancel = false;
+ intercepting_handler->OnWillStart(GURL(), &defer_or_cancel);
+ EXPECT_FALSE(defer_or_cancel);
EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
const std::string kData = "The data";
@@ -269,8 +284,8 @@ TEST_F(InterceptingResourceHandlerTest, HandlerSwitchWithPayload) {
// The response is received. The new ResourceHandler should be used to handle
// the download.
- EXPECT_TRUE(intercepting_handler->OnResponseStarted(response.get(), &defer));
- EXPECT_FALSE(defer);
+ intercepting_handler->OnResponseStarted(response.get(), &defer_or_cancel);
+ EXPECT_FALSE(defer_or_cancel);
// The old handler should have received the payload.
EXPECT_EQ(kPayload, old_handler_body);
@@ -283,8 +298,8 @@ TEST_F(InterceptingResourceHandlerTest, HandlerSwitchWithPayload) {
// The read is replayed by the MimeSniffingResourceHandler. The data should
// have been received by the new handler.
- EXPECT_TRUE(intercepting_handler->OnReadCompleted(kData.length(), &defer));
- EXPECT_FALSE(defer);
+ intercepting_handler->OnReadCompleted(kData.length(), &defer_or_cancel);
+ EXPECT_FALSE(defer_or_cancel);
EXPECT_EQ(kData, std::string(new_test_handler->buffer()->data()));
// Make sure another read behave as expected.
@@ -297,8 +312,8 @@ TEST_F(InterceptingResourceHandlerTest, HandlerSwitchWithPayload) {
EXPECT_NE(kData2, std::string(new_test_handler->buffer()->data()));
memcpy(read_buffer->data(), kData2.c_str(), kData2.length());
- EXPECT_TRUE(intercepting_handler->OnReadCompleted(kData2.length(), &defer));
- EXPECT_FALSE(defer);
+ intercepting_handler->OnReadCompleted(kData2.length(), &defer_or_cancel);
+ EXPECT_FALSE(defer_or_cancel);
EXPECT_EQ(kData2, std::string(new_test_handler->buffer()->data()));
EXPECT_EQ(kData + kData2, new_handler_body);
}
@@ -334,9 +349,9 @@ TEST_F(InterceptingResourceHandlerTest, OldHandlerFailsWillRead) {
// handler should tell the caller to fail.
scoped_refptr<net::IOBuffer> read_buffer;
int buf_size = 0;
- bool defer = false;
- EXPECT_TRUE(intercepting_handler->OnWillStart(GURL(), &defer));
- EXPECT_FALSE(defer);
+ bool defer_or_cancel = false;
+ intercepting_handler->OnWillStart(GURL(), &defer_or_cancel);
+ EXPECT_FALSE(defer_or_cancel);
EXPECT_FALSE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
}
@@ -366,14 +381,18 @@ TEST_F(InterceptingResourceHandlerTest, NewHandlerFailsOnWillStart) {
std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
new InterceptingResourceHandler(std::move(old_handler), request.get()));
+ TestResourceController resource_controller;
+ intercepting_handler->SetController(&resource_controller);
+
scoped_refptr<ResourceResponse> response(new ResourceResponse);
// Simulate the MimeSniffingResourceHandler buffering the data.
scoped_refptr<net::IOBuffer> read_buffer;
int buf_size = 0;
- bool defer = false;
- EXPECT_TRUE(intercepting_handler->OnWillStart(GURL(), &defer));
- EXPECT_FALSE(defer);
+ bool defer_or_cancel = false;
+ intercepting_handler->OnWillStart(GURL(), &defer_or_cancel);
+ EXPECT_FALSE(resource_controller.canceled());
+ EXPECT_FALSE(defer_or_cancel);
EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
const char kData[] = "The data";
@@ -389,10 +408,13 @@ TEST_F(InterceptingResourceHandlerTest, NewHandlerFailsOnWillStart) {
new TestResourceHandler(&new_handler_status, &new_handler_body));
new_handler->set_on_will_start_result(false);
intercepting_handler->UseNewHandler(std::move(new_handler), std::string());
+ EXPECT_FALSE(resource_controller.canceled());
// The response is received. The new ResourceHandler should tell us to fail.
- EXPECT_FALSE(intercepting_handler->OnResponseStarted(response.get(), &defer));
- EXPECT_FALSE(defer);
+ intercepting_handler->OnResponseStarted(response.get(), &defer_or_cancel);
+ EXPECT_TRUE(resource_controller.canceled());
+ EXPECT_EQ(net::ERR_ABORTED, resource_controller.error());
+ EXPECT_TRUE(defer_or_cancel);
}
// Tests that the handler behaves properly if the new handler fails response
@@ -421,14 +443,18 @@ TEST_F(InterceptingResourceHandlerTest, NewHandlerFailsResponseStarted) {
std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
new InterceptingResourceHandler(std::move(old_handler), request.get()));
+ TestResourceController resource_controller;
+ intercepting_handler->SetController(&resource_controller);
+
scoped_refptr<ResourceResponse> response(new ResourceResponse);
// Simulate the MimeSniffingResourceHandler buffering the data.
scoped_refptr<net::IOBuffer> read_buffer;
int buf_size = 0;
- bool defer = false;
- EXPECT_TRUE(intercepting_handler->OnWillStart(GURL(), &defer));
- EXPECT_FALSE(defer);
+ bool defer_or_cancel = false;
+ intercepting_handler->OnWillStart(GURL(), &defer_or_cancel);
+ EXPECT_FALSE(resource_controller.canceled());
+ EXPECT_FALSE(defer_or_cancel);
EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
const char kData[] = "The data";
@@ -444,10 +470,13 @@ TEST_F(InterceptingResourceHandlerTest, NewHandlerFailsResponseStarted) {
new TestResourceHandler(&new_handler_status, &new_handler_body));
new_handler->set_on_response_started_result(false);
intercepting_handler->UseNewHandler(std::move(new_handler), std::string());
+ EXPECT_FALSE(resource_controller.canceled());
// The response is received. The new ResourceHandler should tell us to fail.
- EXPECT_FALSE(intercepting_handler->OnResponseStarted(response.get(), &defer));
- EXPECT_FALSE(defer);
+ intercepting_handler->OnResponseStarted(response.get(), &defer_or_cancel);
+ EXPECT_TRUE(resource_controller.canceled());
+ EXPECT_EQ(net::ERR_ABORTED, resource_controller.error());
+ EXPECT_TRUE(defer_or_cancel);
}
// Tests that the handler behaves properly if the new handler fails will read.
@@ -475,14 +504,18 @@ TEST_F(InterceptingResourceHandlerTest, NewHandlerFailsWillRead) {
std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
new InterceptingResourceHandler(std::move(old_handler), request.get()));
+ TestResourceController resource_controller;
+ intercepting_handler->SetController(&resource_controller);
+
scoped_refptr<ResourceResponse> response(new ResourceResponse);
// Simulate the MimeSniffingResourceHandler buffering the data.
scoped_refptr<net::IOBuffer> read_buffer;
int buf_size = 0;
- bool defer = false;
- EXPECT_TRUE(intercepting_handler->OnWillStart(GURL(), &defer));
- EXPECT_FALSE(defer);
+ bool defer_or_cancel = false;
+ intercepting_handler->OnWillStart(GURL(), &defer_or_cancel);
+ EXPECT_FALSE(resource_controller.canceled());
+ EXPECT_FALSE(defer_or_cancel);
EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
const char kData[] = "The data";
@@ -498,18 +531,22 @@ TEST_F(InterceptingResourceHandlerTest, NewHandlerFailsWillRead) {
new TestResourceHandler(&new_handler_status, &new_handler_body));
new_handler->set_on_will_read_result(false);
intercepting_handler->UseNewHandler(std::move(new_handler), std::string());
+ EXPECT_FALSE(resource_controller.canceled());
// The response is received. The new handler should not have been asked to
// read yet.
- EXPECT_TRUE(intercepting_handler->OnResponseStarted(response.get(), &defer));
- EXPECT_FALSE(defer);
+ intercepting_handler->OnResponseStarted(response.get(), &defer_or_cancel);
+ EXPECT_FALSE(resource_controller.canceled());
+ EXPECT_FALSE(defer_or_cancel);
EXPECT_EQ(net::URLRequestStatus::CANCELED, old_handler_status.status());
EXPECT_EQ(net::ERR_ABORTED, old_handler_status.error());
// The read is replayed by the MimeSniffingResourceHandler. The new
// handler should tell the caller to fail.
- EXPECT_FALSE(intercepting_handler->OnReadCompleted(sizeof(kData), &defer));
- EXPECT_FALSE(defer);
+ intercepting_handler->OnReadCompleted(sizeof(kData), &defer_or_cancel);
+ EXPECT_TRUE(resource_controller.canceled());
+ EXPECT_EQ(net::ERR_ABORTED, resource_controller.error());
+ EXPECT_TRUE(defer_or_cancel);
}
// Tests that the handler behaves properly if the new handler fails read
@@ -538,14 +575,18 @@ TEST_F(InterceptingResourceHandlerTest, NewHandlerFailsReadCompleted) {
std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
new InterceptingResourceHandler(std::move(old_handler), request.get()));
+ TestResourceController resource_controller;
+ intercepting_handler->SetController(&resource_controller);
+
scoped_refptr<ResourceResponse> response(new ResourceResponse);
// Simulate the MimeSniffingResourceHandler buffering the data.
scoped_refptr<net::IOBuffer> read_buffer;
int buf_size = 0;
- bool defer = false;
- EXPECT_TRUE(intercepting_handler->OnWillStart(GURL(), &defer));
- EXPECT_FALSE(defer);
+ bool defer_or_cancel = false;
+ intercepting_handler->OnWillStart(GURL(), &defer_or_cancel);
+ EXPECT_FALSE(resource_controller.canceled());
+ EXPECT_FALSE(defer_or_cancel);
EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
const char kData[] = "The data";
@@ -563,19 +604,22 @@ TEST_F(InterceptingResourceHandlerTest, NewHandlerFailsReadCompleted) {
intercepting_handler->UseNewHandler(std::move(new_handler), std::string());
// The response is received.
- EXPECT_TRUE(intercepting_handler->OnResponseStarted(response.get(), &defer));
- EXPECT_FALSE(defer);
+ intercepting_handler->OnResponseStarted(response.get(), &defer_or_cancel);
+ EXPECT_FALSE(resource_controller.canceled());
+ EXPECT_FALSE(defer_or_cancel);
EXPECT_EQ(net::URLRequestStatus::CANCELED, old_handler_status.status());
EXPECT_EQ(net::ERR_ABORTED, old_handler_status.error());
// The read is replayed by the MimeSniffingResourceHandler. The new handler
// should tell the caller to fail.
- EXPECT_FALSE(intercepting_handler->OnReadCompleted(sizeof(kData), &defer));
- EXPECT_FALSE(defer);
+ intercepting_handler->OnReadCompleted(sizeof(kData), &defer_or_cancel);
+ EXPECT_TRUE(resource_controller.canceled());
+ EXPECT_EQ(net::ERR_ABORTED, resource_controller.error());
+ EXPECT_TRUE(defer_or_cancel);
}
-// The old handler sets |defer| to true in OnReadCompleted and
-// OnResponseCompleted. The new handler sets |defer| to true in
+// The old handler sets |defer_or_cancel| to true in OnReadCompleted and
+// OnResponseCompleted. The new handler sets |defer_or_cancel| to true in
// OnResponseStarted and OnReadCompleted.
TEST_F(InterceptingResourceHandlerTest, DeferredOperations) {
net::URLRequestContext context;
@@ -593,8 +637,6 @@ TEST_F(InterceptingResourceHandlerTest, DeferredOperations) {
true, // is_async
false); // is_using_lofi
- std::unique_ptr<TestResourceController> resource_controller =
- base::MakeUnique<TestResourceController>();
net::URLRequestStatus old_handler_status = {net::URLRequestStatus::IO_PENDING,
0};
std::string old_handler_body;
@@ -606,16 +648,18 @@ TEST_F(InterceptingResourceHandlerTest, DeferredOperations) {
scoped_refptr<net::IOBuffer> old_buffer = old_handler.get()->buffer();
std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
new InterceptingResourceHandler(std::move(old_handler), request.get()));
- intercepting_handler->SetController(resource_controller.get());
+
+ TestResourceController resource_controller;
+ intercepting_handler->SetController(&resource_controller);
scoped_refptr<ResourceResponse> response(new ResourceResponse);
// Simulate the MimeSniffingResourceHandler buffering the data.
scoped_refptr<net::IOBuffer> read_buffer;
int buf_size = 0;
- bool defer = false;
- EXPECT_TRUE(intercepting_handler->OnWillStart(GURL(), &defer));
- EXPECT_FALSE(defer);
+ bool defer_or_cancel = false;
+ intercepting_handler->OnWillStart(GURL(), &defer_or_cancel);
+ EXPECT_FALSE(defer_or_cancel);
EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
const char kData[] = "The data";
@@ -642,8 +686,8 @@ TEST_F(InterceptingResourceHandlerTest, DeferredOperations) {
// The response is received, and then deferred by the old handler's
// OnReadCompleted method.
- ASSERT_TRUE(intercepting_handler->OnResponseStarted(response.get(), &defer));
- ASSERT_TRUE(defer);
+ intercepting_handler->OnResponseStarted(response.get(), &defer_or_cancel);
+ ASSERT_TRUE(defer_or_cancel);
// The old handler has received the first N bytes of the payload synchronously
// where N is the size of the buffer exposed via OnWillRead.
@@ -654,7 +698,7 @@ TEST_F(InterceptingResourceHandlerTest, DeferredOperations) {
// Run until the new handler's OnWillStart method defers the request.
intercepting_handler->Resume();
- EXPECT_EQ(0, resource_controller->resume_calls());
+ EXPECT_EQ(0, resource_controller.resume_calls());
EXPECT_EQ(kPayload, old_handler_body);
EXPECT_EQ(std::string(), new_handler_body);
EXPECT_EQ(old_handler_status.status(), net::URLRequestStatus::SUCCESS);
@@ -662,35 +706,36 @@ TEST_F(InterceptingResourceHandlerTest, DeferredOperations) {
// Run until the new handler's OnResponseStarted method defers the request.
intercepting_handler->Resume();
- EXPECT_EQ(0, resource_controller->resume_calls());
+ EXPECT_EQ(0, resource_controller.resume_calls());
EXPECT_EQ(std::string(), new_handler_body);
EXPECT_EQ(old_handler_status.status(), net::URLRequestStatus::SUCCESS);
EXPECT_EQ(new_handler_status.status(), net::URLRequestStatus::IO_PENDING);
// Resuming should finally call back into the ResourceController.
intercepting_handler->Resume();
- EXPECT_EQ(1, resource_controller->resume_calls());
+ EXPECT_EQ(1, resource_controller.resume_calls());
// Data is read, the new handler defers completion of the read.
- defer = false;
- ASSERT_TRUE(intercepting_handler->OnReadCompleted(strlen(kData), &defer));
- ASSERT_TRUE(defer);
+ defer_or_cancel = false;
+ intercepting_handler->OnReadCompleted(strlen(kData), &defer_or_cancel);
+ ASSERT_TRUE(defer_or_cancel);
EXPECT_EQ(kPayload, old_handler_body);
EXPECT_EQ("T", new_handler_body);
intercepting_handler->Resume();
- EXPECT_EQ(2, resource_controller->resume_calls());
+ EXPECT_EQ(2, resource_controller.resume_calls());
EXPECT_EQ(kPayload, old_handler_body);
EXPECT_EQ(kData, new_handler_body);
EXPECT_EQ(old_handler_status.status(), net::URLRequestStatus::SUCCESS);
EXPECT_EQ(new_handler_status.status(), net::URLRequestStatus::IO_PENDING);
- defer = false;
+ defer_or_cancel = false;
intercepting_handler->OnResponseCompleted({net::URLRequestStatus::SUCCESS, 0},
- &defer);
- ASSERT_TRUE(defer);
+ &defer_or_cancel);
+ EXPECT_FALSE(resource_controller.canceled());
+ ASSERT_TRUE(defer_or_cancel);
EXPECT_EQ(old_handler_status.status(), net::URLRequestStatus::SUCCESS);
EXPECT_EQ(new_handler_status.status(), net::URLRequestStatus::SUCCESS);
}
@@ -713,8 +758,6 @@ TEST_F(InterceptingResourceHandlerTest, CancelOldHandler) {
true, // is_async
false); // is_using_lofi
- std::unique_ptr<TestResourceController> resource_controller =
- base::MakeUnique<TestResourceController>();
net::URLRequestStatus old_handler_status = {net::URLRequestStatus::IO_PENDING,
0};
std::string old_handler_body;
@@ -723,15 +766,18 @@ TEST_F(InterceptingResourceHandlerTest, CancelOldHandler) {
std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
new InterceptingResourceHandler(std::move(old_handler), request.get()));
- intercepting_handler->SetController(resource_controller.get());
+
+ TestResourceController resource_controller;
+ intercepting_handler->SetController(&resource_controller);
EXPECT_EQ(net::URLRequestStatus::IO_PENDING, old_handler_status.status());
- bool defer = false;
+ bool defer_or_cancel = false;
intercepting_handler->OnResponseCompleted(
- {net::URLRequestStatus::CANCELED, net::ERR_FAILED}, &defer);
- ASSERT_FALSE(defer);
- EXPECT_EQ(0, resource_controller->resume_calls());
+ {net::URLRequestStatus::CANCELED, net::ERR_FAILED}, &defer_or_cancel);
+ ASSERT_FALSE(defer_or_cancel);
+ EXPECT_EQ(0, resource_controller.resume_calls());
+ EXPECT_FALSE(resource_controller.canceled());
EXPECT_EQ(net::URLRequestStatus::CANCELED, old_handler_status.status());
}
@@ -753,8 +799,6 @@ TEST_F(InterceptingResourceHandlerTest, CancelNewHandler) {
true, // is_async
false); // is_using_lofi
- std::unique_ptr<TestResourceController> resource_controller =
- base::MakeUnique<TestResourceController>();
net::URLRequestStatus old_handler_status = {net::URLRequestStatus::IO_PENDING,
0};
std::string old_handler_body;
@@ -763,16 +807,18 @@ TEST_F(InterceptingResourceHandlerTest, CancelNewHandler) {
std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
new InterceptingResourceHandler(std::move(old_handler), request.get()));
- intercepting_handler->SetController(resource_controller.get());
+
+ TestResourceController resource_controller;
+ intercepting_handler->SetController(&resource_controller);
scoped_refptr<ResourceResponse> response(new ResourceResponse);
// Simulate the MimeSniffingResourceHandler buffering the data.
scoped_refptr<net::IOBuffer> read_buffer;
int buf_size = 0;
- bool defer = false;
- EXPECT_TRUE(intercepting_handler->OnWillStart(GURL(), &defer));
- EXPECT_FALSE(defer);
+ bool defer_or_cancel = false;
+ intercepting_handler->OnWillStart(GURL(), &defer_or_cancel);
+ EXPECT_FALSE(defer_or_cancel);
EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
const char kData[] = "The data";
@@ -794,17 +840,18 @@ TEST_F(InterceptingResourceHandlerTest, CancelNewHandler) {
intercepting_handler->UseNewHandler(std::move(new_handler), kPayload);
// The response is received.
- ASSERT_TRUE(intercepting_handler->OnResponseStarted(response.get(), &defer));
- ASSERT_TRUE(defer);
+ intercepting_handler->OnResponseStarted(response.get(), &defer_or_cancel);
+ ASSERT_TRUE(defer_or_cancel);
EXPECT_EQ(net::URLRequestStatus::SUCCESS, old_handler_status.status());
EXPECT_EQ(net::URLRequestStatus::IO_PENDING, new_handler_status.status());
- defer = false;
+ defer_or_cancel = false;
intercepting_handler->OnResponseCompleted(
- {net::URLRequestStatus::CANCELED, net::ERR_FAILED}, &defer);
- ASSERT_TRUE(defer);
- EXPECT_EQ(0, resource_controller->resume_calls());
+ {net::URLRequestStatus::CANCELED, net::ERR_FAILED}, &defer_or_cancel);
+ ASSERT_TRUE(defer_or_cancel);
+ EXPECT_EQ(0, resource_controller.resume_calls());
+ EXPECT_FALSE(resource_controller.canceled());
EXPECT_EQ(net::URLRequestStatus::SUCCESS, old_handler_status.status());
EXPECT_EQ(net::URLRequestStatus::CANCELED, new_handler_status.status());
}
@@ -827,8 +874,6 @@ TEST_F(InterceptingResourceHandlerTest, CancelBothHandlers) {
true, // is_async
false); // is_using_lofi
- std::unique_ptr<TestResourceController> resource_controller =
- base::MakeUnique<TestResourceController>();
net::URLRequestStatus old_handler_status = {net::URLRequestStatus::IO_PENDING,
0};
std::string old_handler_body;
@@ -838,16 +883,19 @@ TEST_F(InterceptingResourceHandlerTest, CancelBothHandlers) {
std::unique_ptr<InterceptingResourceHandler> intercepting_handler(
new InterceptingResourceHandler(std::move(old_handler), request.get()));
- intercepting_handler->SetController(resource_controller.get());
+
+ TestResourceController resource_controller;
+ intercepting_handler->SetController(&resource_controller);
scoped_refptr<ResourceResponse> response(new ResourceResponse);
// Simulate the MimeSniffingResourceHandler buffering the data.
scoped_refptr<net::IOBuffer> read_buffer;
int buf_size = 0;
- bool defer = false;
- EXPECT_TRUE(intercepting_handler->OnWillStart(GURL(), &defer));
- EXPECT_FALSE(defer);
+ bool defer_or_cancel = false;
+ intercepting_handler->OnWillStart(GURL(), &defer_or_cancel);
+ EXPECT_FALSE(resource_controller.canceled());
+ EXPECT_FALSE(defer_or_cancel);
EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));
const char kData[] = "The data";
@@ -868,17 +916,19 @@ TEST_F(InterceptingResourceHandlerTest, CancelBothHandlers) {
intercepting_handler->UseNewHandler(std::move(new_handler), kPayload);
// The response is received.
- ASSERT_TRUE(intercepting_handler->OnResponseStarted(response.get(), &defer));
- ASSERT_TRUE(defer);
+ intercepting_handler->OnResponseStarted(response.get(), &defer_or_cancel);
+ EXPECT_FALSE(resource_controller.canceled());
+ ASSERT_TRUE(defer_or_cancel);
EXPECT_EQ(net::URLRequestStatus::IO_PENDING, old_handler_status.status());
EXPECT_EQ(net::URLRequestStatus::IO_PENDING, new_handler_status.status());
- defer = false;
+ defer_or_cancel = false;
intercepting_handler->OnResponseCompleted(
- {net::URLRequestStatus::CANCELED, net::ERR_FAILED}, &defer);
- ASSERT_TRUE(defer);
- EXPECT_EQ(0, resource_controller->resume_calls());
+ {net::URLRequestStatus::CANCELED, net::ERR_FAILED}, &defer_or_cancel);
+ EXPECT_FALSE(resource_controller.canceled());
+ ASSERT_TRUE(defer_or_cancel);
+ EXPECT_EQ(0, resource_controller.resume_calls());
EXPECT_EQ(net::URLRequestStatus::CANCELED, old_handler_status.status());
EXPECT_EQ(net::URLRequestStatus::CANCELED, new_handler_status.status());
}
« no previous file with comments | « content/browser/loader/intercepting_resource_handler.cc ('k') | content/browser/loader/layered_resource_handler.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698