content/browser/loader/intercepting_resource_handler_unittest.cc - Issue 2327463002: Relax ad-hoc assumptions on InterceptingResourceHandler

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

Issue 2327463002: Relax ad-hoc assumptions on InterceptingResourceHandler (Closed)

Patch Set: fix Created 4 years, 2 months 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

« content/browser/loader/intercepting_resource_handler.cc ('K') | « content/browser/loader/intercepting_resource_handler.cc ('k') | content/browser/loader/mime_sniffing_resource_handler_unittest.cc » ('j') | content/browser/loader/mime_sniffing_resource_handler_unittest.cc » ('J')
Expand Comments ('e') | Collapse Comments ('c') | 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 3ae9dead69e8b999fb2b3c9212d271f8a7feaf5d..8e78f136b54f26f76cd61d4f85cb013e3b5a9408 100644

--- a/content/browser/loader/intercepting_resource_handler_unittest.cc

+++ b/content/browser/loader/intercepting_resource_handler_unittest.cc

@@ -12,6 +12,7 @@

#include "base/location.h"

#include "base/logging.h"

#include "base/macros.h"

+#include "base/memory/ptr_util.h"

#include "base/single_thread_task_runner.h"

#include "base/threading/thread_task_runner_handle.h"

#include "content/public/browser/resource_controller.h"

@@ -30,37 +31,74 @@ namespace content {

namespace {

+class TestResourceController : public ResourceController {

+ public:

+ void Cancel() override {}

+ void CancelAndIgnore() override {}

+ void CancelWithError(int error_code) override {}

+ void Resume() override { ++num_resume_called_; }

+ int num_resume_called() const { return num_resume_called_; }

mmenke 2016/10/11 21:34:35 times_resume_called? num_times_resumed_called? r

yhirano 2016/10/12 10:36:21 Done.

+ private:

+ int num_resume_called_ = 0;

mmenke 2016/10/11 21:34:35 DISALLOW_COPY_AND_ASSIGN?

yhirano 2016/10/12 10:36:21 Done.

+};

class TestResourceHandler : public ResourceHandler {

public:

- // A test version of a ResourceHandler. |request_status| and

- // |final_bytes_read| will be updated when the response is complete with the

- // final status of the request received by the handler, and the total bytes

- // the handler saw.

+ // A test version of a ResourceHandler. |request_status| will be updated when

+ // the response is complete with the final status of the request received by

+ // the handler and |body| will be updated on each OnReadCompleted call.

explicit TestResourceHandler(net::URLRequestStatus* request_status,

- size_t* final_bytes_read)

+ std::string* body)

: TestResourceHandler(request_status,

- final_bytes_read,

+ body,

+ 2048 /* buffer_size */,

true /* on_response_started_result */,

true /* on_will_read_result */,

- true /* on_read_completed_result */) {}

+ true /* on_read_completed_result */,

+ false /* defer_on_response_started */,

+ false /* defer_on_read_completed */,

+ false /* defer_on_response_completed */) {}

// This constructor allows to specify return values for OnResponseStarted,

// OnWillRead and OnReadCompleted.

TestResourceHandler(net::URLRequestStatus* request_status,

- size_t* final_bytes_read,

+ std::string* body,

bool on_response_started_result,

bool on_will_read_result,

bool on_read_completed_result)

+ : TestResourceHandler(request_status,

+ body,

+ 2048 /* buffer_size */,

+ on_response_started_result,

+ on_will_read_result,

+ on_read_completed_result,

+ false /* defer_on_response_started */,

+ false /* defer_on_response_completed */,

+ false /* defer_on_read_completed */) {}

+ TestResourceHandler(net::URLRequestStatus* request_status,

+ std::string* body,

+ size_t buffer_size,

+ bool on_response_started_result,

+ bool on_will_read_result,

+ bool on_read_completed_result,

+ bool defer_on_response_started,

+ bool defer_on_read_completed,

+ bool defer_on_response_completed)

: ResourceHandler(nullptr),

- buffer_(new net::IOBuffer(2048)),

request_status_(request_status),

- final_bytes_read_(final_bytes_read),

+ body_(body),

+ buffer_(new net::IOBuffer(buffer_size)),

+ buffer_size_(buffer_size),

on_response_started_result_(on_response_started_result),

on_will_read_result_(on_will_read_result),

on_read_completed_result_(on_read_completed_result),

- bytes_read_(0),

- is_completed_(false) {

- memset(buffer_->data(), '\0', 2048);

+ defer_on_response_started_(defer_on_response_started),

+ defer_on_read_completed_(defer_on_read_completed),

+ defer_on_response_completed_(defer_on_response_completed) {

+ memset(buffer_->data(), '\0', buffer_size_);

}

~TestResourceHandler() override {}

@@ -76,7 +114,11 @@ class TestResourceHandler : public ResourceHandler {

bool OnResponseStarted(ResourceResponse* response, bool* defer) override {

EXPECT_FALSE(is_completed_);

- return on_response_started_result_;

+ if (!on_response_started_result_)

+ return false;

+ *defer = defer_on_response_started_;

+ defer_on_response_started_ = false;

+ return true;

}

bool OnWillStart(const GURL& url, bool* defer) override {

@@ -89,16 +131,20 @@ class TestResourceHandler : public ResourceHandler {

int min_size) override {

EXPECT_FALSE(is_completed_);

*buf = buffer_;

- *buf_size = 2048;

- memset(buffer_->data(), '\0', 2048);

+ *buf_size = buffer_size_;

+ memset(buffer_->data(), '\0', buffer_size_);

return on_will_read_result_;

}

bool OnReadCompleted(int bytes_read, bool* defer) override {

EXPECT_FALSE(is_completed_);

- EXPECT_LT(bytes_read, 2048);

- bytes_read_ += bytes_read;

- return on_read_completed_result_;

+ EXPECT_LE(static_cast<size_t>(bytes_read), buffer_size_);

+ body_->append(buffer_->data(), bytes_read);

+ if (!on_read_completed_result_)

+ return false;

+ *defer = defer_on_read_completed_;

+ defer_on_read_completed_ = false;

+ return true;

}

void OnResponseCompleted(const net::URLRequestStatus& status,

@@ -106,24 +152,26 @@ class TestResourceHandler : public ResourceHandler {

EXPECT_FALSE(is_completed_);

is_completed_ = true;

*request_status_ = status;

- *final_bytes_read_ = bytes_read_;

+ *defer = defer_on_response_completed_;

+ defer_on_response_completed_ = false;

}

void OnDataDownloaded(int bytes_downloaded) override { NOTREACHED(); }

scoped_refptr<net::IOBuffer> buffer() const { return buffer_; }

- size_t bytes_read() const { return bytes_read_; }

private:

- scoped_refptr<net::IOBuffer> buffer_;

net::URLRequestStatus* request_status_;

- size_t* final_bytes_read_;

- bool on_response_started_result_;

- bool on_will_read_result_;

- bool on_read_completed_result_;

- size_t bytes_read_;

- bool is_completed_;

+ std::string* body_;

+ scoped_refptr<net::IOBuffer> buffer_;

+ const size_t buffer_size_;

+ const bool on_response_started_result_;

+ const bool on_will_read_result_;

+ const bool on_read_completed_result_;

+ bool defer_on_response_started_;

+ bool defer_on_read_completed_;

+ bool defer_on_response_completed_;

+ bool is_completed_ = false;

DISALLOW_COPY_AND_ASSIGN(TestResourceHandler);

};

@@ -155,9 +203,9 @@ TEST_F(InterceptingResourceHandlerTest, NoSwitching) {

false); // is_using_lofi

net::URLRequestStatus old_handler_status;

- size_t old_handler_final_bytes_read = 0;

- std::unique_ptr<TestResourceHandler> old_handler(new TestResourceHandler(

- &old_handler_status, &old_handler_final_bytes_read));

+ std::string old_handler_body;

mmenke 2016/10/11 21:34:35 include <string>

yhirano 2016/10/12 10:36:21 Done.

+ std::unique_ptr<TestResourceHandler> old_handler(

+ new TestResourceHandler(&old_handler_status, &old_handler_body));

TestResourceHandler* old_test_handler = old_handler.get();

scoped_refptr<net::IOBuffer> old_buffer = old_handler.get()->buffer();

std::unique_ptr<InterceptingResourceHandler> intercepting_handler(

@@ -176,7 +224,7 @@ TEST_F(InterceptingResourceHandlerTest, NoSwitching) {

const std::string kData = "The data";

EXPECT_NE(kData, std::string(old_test_handler->buffer()->data()));

- ASSERT_EQ(read_buffer.get(), old_test_handler->buffer());

+ ASSERT_NE(read_buffer.get(), old_test_handler->buffer());

ASSERT_GT(static_cast<size_t>(buf_size), kData.length());

memcpy(read_buffer->data(), kData.c_str(), kData.length());

@@ -203,7 +251,7 @@ TEST_F(InterceptingResourceHandlerTest, NoSwitching) {

EXPECT_TRUE(intercepting_handler->OnReadCompleted(kData2.length(), &defer));

EXPECT_FALSE(defer);

EXPECT_EQ(kData2, std::string(old_test_handler->buffer()->data()));

- EXPECT_EQ(kData.length() + kData2.length(), old_test_handler->bytes_read());

+ EXPECT_EQ(std::string(kData) + kData2, old_handler_body);

}

// Tests that the data received is transmitted to the newly created

@@ -225,9 +273,9 @@ TEST_F(InterceptingResourceHandlerTest, HandlerSwitchNoPayload) {

false); // is_using_lofi

net::URLRequestStatus old_handler_status;

- size_t old_handler_final_bytes_read = 0;

- std::unique_ptr<TestResourceHandler> old_handler(new TestResourceHandler(

- &old_handler_status, &old_handler_final_bytes_read));

+ std::string old_handler_body;

+ std::unique_ptr<TestResourceHandler> old_handler(

+ new TestResourceHandler(&old_handler_status, &old_handler_body));

scoped_refptr<net::IOBuffer> old_buffer = old_handler.get()->buffer();

std::unique_ptr<InterceptingResourceHandler> intercepting_handler(

new InterceptingResourceHandler(std::move(old_handler), request.get()));

@@ -243,17 +291,16 @@ TEST_F(InterceptingResourceHandlerTest, HandlerSwitchNoPayload) {

EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));

const std::string kData = "The data";

- ASSERT_EQ(read_buffer.get(), old_buffer.get());

+ ASSERT_NE(read_buffer.get(), old_buffer.get());

ASSERT_GT(static_cast<size_t>(buf_size), kData.length());

memcpy(read_buffer->data(), kData.c_str(), kData.length());

// Simulate the MimeSniffingResourceHandler asking the

// InterceptingResourceHandler to switch to a new handler.

net::URLRequestStatus new_handler_status;

- size_t new_handler_final_bytes_read = 0;

+ std::string new_handler_body;

std::unique_ptr<TestResourceHandler> new_handler_scoped(

- new TestResourceHandler(&new_handler_status,

- &new_handler_final_bytes_read));

+ new TestResourceHandler(&new_handler_status, &new_handler_body));

TestResourceHandler* new_test_handler = new_handler_scoped.get();

intercepting_handler->UseNewHandler(std::move(new_handler_scoped),

std::string());

@@ -265,7 +312,7 @@ TEST_F(InterceptingResourceHandlerTest, HandlerSwitchNoPayload) {

EXPECT_FALSE(old_handler_status.is_success());

EXPECT_EQ(net::ERR_ABORTED, old_handler_status.error());

- EXPECT_EQ(0ul, old_handler_final_bytes_read);

+ EXPECT_EQ(std::string(), old_handler_body);

// It should not have received the download data yet.

EXPECT_NE(kData, std::string(new_test_handler->buffer()->data()));

@@ -289,7 +336,7 @@ TEST_F(InterceptingResourceHandlerTest, HandlerSwitchNoPayload) {

EXPECT_TRUE(intercepting_handler->OnReadCompleted(kData2.length(), &defer));

EXPECT_FALSE(defer);

EXPECT_EQ(kData2, std::string(new_test_handler->buffer()->data()));

- EXPECT_EQ(kData.length() + kData2.length(), new_test_handler->bytes_read());

+ EXPECT_EQ(kData + kData2, new_handler_body);

}

// Tests that the data received is transmitted to the newly created

@@ -311,10 +358,9 @@ TEST_F(InterceptingResourceHandlerTest, HandlerSwitchWithPayload) {

false); // is_using_lofi

net::URLRequestStatus old_handler_status;

- size_t old_handler_final_bytes_read = 0;

+ std::string old_handler_body;

std::unique_ptr<TestResourceHandler> old_handler_scoped(

- new TestResourceHandler(&old_handler_status,

- &old_handler_final_bytes_read));

+ new TestResourceHandler(&old_handler_status, &old_handler_body));

TestResourceHandler* old_handler = old_handler_scoped.get();

scoped_refptr<net::IOBuffer> old_buffer = old_handler->buffer();

std::unique_ptr<InterceptingResourceHandler> intercepting_handler(

@@ -332,7 +378,7 @@ TEST_F(InterceptingResourceHandlerTest, HandlerSwitchWithPayload) {

EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));

const std::string kData = "The data";

- ASSERT_EQ(read_buffer.get(), old_buffer.get());

+ ASSERT_NE(read_buffer.get(), old_buffer.get());

ASSERT_GT(static_cast<size_t>(buf_size), kData.length());

memcpy(read_buffer->data(), kData.c_str(), kData.length());

@@ -340,15 +386,14 @@ TEST_F(InterceptingResourceHandlerTest, HandlerSwitchWithPayload) {

// InterceptingResourceHandler to switch to a new handler.

const std::string kPayload = "The payload";

net::URLRequestStatus new_handler_status;

- size_t new_handler_final_bytes_read = 0;

+ std::string new_handler_body;

std::unique_ptr<TestResourceHandler> new_handler_scoped(

- new TestResourceHandler(&new_handler_status,

- &new_handler_final_bytes_read));

+ new TestResourceHandler(&new_handler_status, &new_handler_body));

TestResourceHandler* new_test_handler = new_handler_scoped.get();

intercepting_handler->UseNewHandler(std::move(new_handler_scoped), kPayload);

// The old handler should not have received the payload yet.

- ASSERT_FALSE(old_handler->bytes_read());

+ ASSERT_EQ("", old_handler_body);

EXPECT_NE(kPayload, std::string(old_buffer->data()));

// The response is received. The new ResourceHandler should be used to handle

@@ -357,7 +402,7 @@ TEST_F(InterceptingResourceHandlerTest, HandlerSwitchWithPayload) {

EXPECT_FALSE(defer);

// The old handler should have received the payload.

- ASSERT_TRUE(old_handler_final_bytes_read == kPayload.size());

+ EXPECT_EQ(kPayload, old_handler_body);

EXPECT_EQ(kPayload, std::string(old_buffer->data()));

EXPECT_TRUE(old_handler_status.is_success());

@@ -385,7 +430,7 @@ TEST_F(InterceptingResourceHandlerTest, HandlerSwitchWithPayload) {

EXPECT_TRUE(intercepting_handler->OnReadCompleted(kData2.length(), &defer));

EXPECT_FALSE(defer);

EXPECT_EQ(kData2, std::string(new_test_handler->buffer()->data()));

- EXPECT_EQ(kData.length() + kData2.length(), new_test_handler->bytes_read());

+ EXPECT_EQ(kData + kData2, new_handler_body);

}

// Tests that the handler behaves properly if the old handler fails will read.

@@ -406,12 +451,12 @@ TEST_F(InterceptingResourceHandlerTest, OldHandlerFailsWillRead) {

false); // is_using_lofi

net::URLRequestStatus old_handler_status;

- size_t old_handler_final_bytes_read = 0;

- std::unique_ptr<TestResourceHandler> old_handler(new TestResourceHandler(

- &old_handler_status, &old_handler_final_bytes_read,

- true, // on_response_started

- false, // on_will_read

- true)); // on_read_completed

+ std::string old_handler_body;

+ std::unique_ptr<TestResourceHandler> old_handler(

+ new TestResourceHandler(&old_handler_status, &old_handler_body,

+ true, // on_response_started

+ false, // on_will_read

+ true)); // on_read_completed

scoped_refptr<net::IOBuffer> old_buffer = old_handler.get()->buffer();

std::unique_ptr<InterceptingResourceHandler> intercepting_handler(

new InterceptingResourceHandler(std::move(old_handler), request.get()));

@@ -447,9 +492,9 @@ TEST_F(InterceptingResourceHandlerTest, NewHandlerFailsResponseStarted) {

false); // is_using_lofi

net::URLRequestStatus old_handler_status;

- size_t old_handler_final_bytes_read = 0;

- std::unique_ptr<TestResourceHandler> old_handler(new TestResourceHandler(

- &old_handler_status, &old_handler_final_bytes_read));

+ std::string old_handler_body;

+ std::unique_ptr<TestResourceHandler> old_handler(

+ new TestResourceHandler(&old_handler_status, &old_handler_body));

scoped_refptr<net::IOBuffer> old_buffer = old_handler.get()->buffer();

std::unique_ptr<InterceptingResourceHandler> intercepting_handler(

new InterceptingResourceHandler(std::move(old_handler), request.get()));

@@ -465,19 +510,19 @@ TEST_F(InterceptingResourceHandlerTest, NewHandlerFailsResponseStarted) {

EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));

const char kData[] = "The data";

- ASSERT_EQ(read_buffer.get(), old_buffer.get());

+ ASSERT_NE(read_buffer.get(), old_buffer.get());

ASSERT_GT(static_cast<size_t>(buf_size), sizeof(kData));

memcpy(read_buffer->data(), kData, sizeof(kData));

// Simulate the MimeSniffingResourceHandler asking the

// InterceptingResourceHandler to switch to a new handler.

net::URLRequestStatus new_handler_status;

- size_t new_handler_final_bytes_read = 0;

- std::unique_ptr<TestResourceHandler> new_handler(new TestResourceHandler(

- &new_handler_status, &new_handler_final_bytes_read,

- false, // on_response_started

- true, // on_will_read

- true)); // on_read_completed

+ std::string new_handler_body;

+ std::unique_ptr<TestResourceHandler> new_handler(

+ new TestResourceHandler(&new_handler_status, &new_handler_body,

+ false, // on_response_started

+ true, // on_will_read

+ true)); // on_read_completed

intercepting_handler->UseNewHandler(std::move(new_handler), std::string());

// The response is received. The new ResourceHandler should tell us to fail.

@@ -503,9 +548,9 @@ TEST_F(InterceptingResourceHandlerTest, NewHandlerFailsWillRead) {

false); // is_using_lofi

net::URLRequestStatus old_handler_status;

- size_t old_handler_final_bytes_read = 0;

- std::unique_ptr<TestResourceHandler> old_handler(new TestResourceHandler(

- &old_handler_status, &old_handler_final_bytes_read));

+ std::string old_handler_body;

+ std::unique_ptr<TestResourceHandler> old_handler(

+ new TestResourceHandler(&old_handler_status, &old_handler_body));

scoped_refptr<net::IOBuffer> old_buffer = old_handler.get()->buffer();

std::unique_ptr<InterceptingResourceHandler> intercepting_handler(

new InterceptingResourceHandler(std::move(old_handler), request.get()));

@@ -521,19 +566,19 @@ TEST_F(InterceptingResourceHandlerTest, NewHandlerFailsWillRead) {

EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));

const char kData[] = "The data";

- ASSERT_EQ(read_buffer.get(), old_buffer.get());

+ ASSERT_NE(read_buffer.get(), old_buffer.get());

ASSERT_GT(static_cast<size_t>(buf_size), sizeof(kData));

memcpy(read_buffer->data(), kData, sizeof(kData));

// Simulate the MimeSniffingResourceHandler asking the

// InterceptingResourceHandler to switch to a new handler.

net::URLRequestStatus new_handler_status;

- size_t new_handler_final_bytes_read = 0;

- std::unique_ptr<TestResourceHandler> new_handler(new TestResourceHandler(

- &new_handler_status, &new_handler_final_bytes_read,

- true, // on_response_started

- false, // on_will_read

- true)); // on_read_completed

+ std::string new_handler_body;

+ std::unique_ptr<TestResourceHandler> new_handler(

+ new TestResourceHandler(&new_handler_status, &new_handler_body,

+ true, // on_response_started

+ false, // on_will_read

+ true)); // on_read_completed

intercepting_handler->UseNewHandler(std::move(new_handler), std::string());

// The response is received. The new handler should not have been asked to

@@ -568,9 +613,9 @@ TEST_F(InterceptingResourceHandlerTest, NewHandlerFailsReadCompleted) {

false); // is_using_lofi

net::URLRequestStatus old_handler_status;

- size_t old_handler_final_bytes_read = 0;

- std::unique_ptr<TestResourceHandler> old_handler(new TestResourceHandler(

- &old_handler_status, &old_handler_final_bytes_read));

+ std::string old_handler_body;

+ std::unique_ptr<TestResourceHandler> old_handler(

+ new TestResourceHandler(&old_handler_status, &old_handler_body));

scoped_refptr<net::IOBuffer> old_buffer = old_handler.get()->buffer();

std::unique_ptr<InterceptingResourceHandler> intercepting_handler(

new InterceptingResourceHandler(std::move(old_handler), request.get()));

@@ -586,19 +631,19 @@ TEST_F(InterceptingResourceHandlerTest, NewHandlerFailsReadCompleted) {

EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));

const char kData[] = "The data";

- ASSERT_EQ(read_buffer.get(), old_buffer.get());

+ ASSERT_NE(read_buffer.get(), old_buffer.get());

ASSERT_GT(static_cast<size_t>(buf_size), sizeof(kData));

memcpy(read_buffer->data(), kData, sizeof(kData));

// Simulate the MimeSniffingResourceHandler asking the

// InterceptingResourceHandler to switch to a new handler.

net::URLRequestStatus new_handler_status;

- size_t new_handler_final_bytes_read = 0;

- std::unique_ptr<TestResourceHandler> new_handler(new TestResourceHandler(

- &new_handler_status, &new_handler_final_bytes_read,

- true, // on_response_started

- true, // on_will_read

- false)); // on_read_completed

+ std::string new_handler_body;

+ std::unique_ptr<TestResourceHandler> new_handler(

+ new TestResourceHandler(&new_handler_status, &new_handler_body,

+ true, // on_response_started

+ true, // on_will_read

+ false)); // on_read_completed

intercepting_handler->UseNewHandler(std::move(new_handler), std::string());

// The response is received.

@@ -613,6 +658,203 @@ TEST_F(InterceptingResourceHandlerTest, NewHandlerFailsReadCompleted) {

EXPECT_FALSE(defer);

}

+// The old handler and the new handler set |defer| to true.

+TEST_F(InterceptingResourceHandlerTest, DeferredOperations) {

+ net::URLRequestContext context;

+ std::unique_ptr<net::URLRequest> request(context.CreateRequest(

+ GURL("http://www.google.com"), net::DEFAULT_PRIORITY, nullptr));

+ ResourceRequestInfo::AllocateForTesting(request.get(),

+ RESOURCE_TYPE_MAIN_FRAME,

+ nullptr, // context

+ 0, // render_process_id

+ 0, // render_view_id

+ 0, // render_frame_id

+ true, // is_main_frame

+ false, // parent_is_main_frame

+ true, // allow_download

+ 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;

+ std::unique_ptr<TestResourceHandler> old_handler(

+ new TestResourceHandler(&old_handler_status, &old_handler_body,

+ 10, // buffer_size

+ true, // on_response_started

+ true, // on_will_read

+ true, // on_read_completed

+ false, // defer_on_response_started

+ true, // defer_on_read_completed

+ false)); // defer_on_response_completed

+ 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());

+ 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);

+ EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));

+ const char kData[] = "The data";

+ ASSERT_NE(read_buffer.get(), old_buffer.get());

+ ASSERT_GT(static_cast<size_t>(buf_size), strlen(kData));

+ memcpy(read_buffer->data(), kData, strlen(kData));

+ // Simulate the MimeSniffingResourceHandler asking the

+ // InterceptingResourceHandler to switch to a new handler.

+ net::URLRequestStatus new_handler_status = {net::URLRequestStatus::IO_PENDING,

+ 0};

+ std::string new_handler_body;

+ const std::string kPayload = "The long long long long long payload";

+ ASSERT_GT(kPayload.size(), static_cast<size_t>(buf_size));

+ std::unique_ptr<TestResourceHandler> new_handler(

+ new TestResourceHandler(&new_handler_status, &new_handler_body,

+ 1, // buffer_size

+ true, // on_response_started

+ true, // on_will_read

+ true, // on_read_completed

+ true, // defer_on_response_started

+ true, // defer_on_read_completed

+ true)); // defer_on_response_completed

+ intercepting_handler->UseNewHandler(std::move(new_handler), kPayload);

+ // The response is received.

+ ASSERT_TRUE(intercepting_handler->OnResponseStarted(response.get(), &defer));

+ ASSERT_TRUE(defer);

+ EXPECT_EQ("The long l", old_handler_body);

+ EXPECT_EQ(std::string(), new_handler_body);

+ intercepting_handler->Resume();

+ EXPECT_EQ(0, resource_controller->num_resume_called());

+ EXPECT_EQ(kPayload, old_handler_body);

+ EXPECT_EQ(std::string(), new_handler_body);

+ intercepting_handler->Resume();

+ EXPECT_EQ(1, resource_controller->num_resume_called());

+ EXPECT_EQ(kPayload, old_handler_body);

+ EXPECT_EQ(std::string(), new_handler_body);

+ defer = false;

+ ASSERT_TRUE(intercepting_handler->OnReadCompleted(strlen(kData), &defer));

+ ASSERT_TRUE(defer);

+ EXPECT_EQ(kPayload, old_handler_body);

+ EXPECT_EQ("T", new_handler_body);

+ intercepting_handler->Resume();

+ EXPECT_EQ(2, resource_controller->num_resume_called());

+ 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;

+ intercepting_handler->OnResponseCompleted({net::URLRequestStatus::SUCCESS, 0},

+ &defer);

+ ASSERT_TRUE(defer);

+ EXPECT_EQ(old_handler_status.status(), net::URLRequestStatus::SUCCESS);

+ EXPECT_EQ(new_handler_status.status(), net::URLRequestStatus::SUCCESS);

+TEST_F(InterceptingResourceHandlerTest, DeferredCompletion) {

+ net::URLRequestContext context;

+ std::unique_ptr<net::URLRequest> request(context.CreateRequest(

+ GURL("http://www.google.com"), net::DEFAULT_PRIORITY, nullptr));

+ ResourceRequestInfo::AllocateForTesting(request.get(),

+ RESOURCE_TYPE_MAIN_FRAME,

+ nullptr, // context

+ 0, // render_process_id

+ 0, // render_view_id

+ 0, // render_frame_id

+ true, // is_main_frame

+ false, // parent_is_main_frame

+ true, // allow_download

+ 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;

+ std::unique_ptr<TestResourceHandler> old_handler(

+ new TestResourceHandler(&old_handler_status, &old_handler_body,

+ 2048, // buffer_size

+ true, // on_response_started

+ true, // on_will_read

+ false, // on_read_completed

+ false, // defer_on_response_started

+ false, // defer_on_read_completed

+ false)); // defer_on_response_completed

+ std::unique_ptr<InterceptingResourceHandler> intercepting_handler(

+ new InterceptingResourceHandler(std::move(old_handler), request.get()));

+ intercepting_handler->SetController(resource_controller.get());

+ 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);

+ EXPECT_TRUE(intercepting_handler->OnWillRead(&read_buffer, &buf_size, -1));

+ const char kData[] = "The data";

+ ASSERT_GT(static_cast<size_t>(buf_size), strlen(kData));

+ memcpy(read_buffer->data(), kData, strlen(kData));

+ // Simulate the MimeSniffingResourceHandler asking the

+ // InterceptingResourceHandler to switch to a new handler.

+ net::URLRequestStatus new_handler_status = {net::URLRequestStatus::IO_PENDING,

+ 0};

+ std::string new_handler_body;

+ const std::string kPayload = "The payload";

+ std::unique_ptr<TestResourceHandler> new_handler(

+ new TestResourceHandler(&new_handler_status, &new_handler_body,

+ 1, // buffer_size

+ true, // on_response_started

+ true, // on_will_read

+ true, // on_read_completed

+ false, // defer_on_response_started

+ false, // defer_on_read_completed

+ true)); // defer_on_response_completed

+ intercepting_handler->UseNewHandler(std::move(new_handler), kPayload);

+ // The response is received.

+ ASSERT_FALSE(intercepting_handler->OnResponseStarted(response.get(), &defer));

+ ASSERT_FALSE(defer);

+ EXPECT_EQ(net::URLRequestStatus::IO_PENDING, old_handler_status.status());

+ EXPECT_EQ(net::URLRequestStatus::IO_PENDING, new_handler_status.status());

+ intercepting_handler->OnResponseCompleted(

+ {net::URLRequestStatus::CANCELED, net::ERR_FAILED}, &defer);

+ ASSERT_TRUE(defer);

+ EXPECT_EQ(0, resource_controller->num_resume_called());

+ EXPECT_EQ(net::URLRequestStatus::CANCELED, old_handler_status.status());

+ EXPECT_EQ(net::URLRequestStatus::CANCELED, new_handler_status.status());

+ intercepting_handler->Resume();

+ EXPECT_EQ(1, resource_controller->num_resume_called());

+ EXPECT_EQ(net::URLRequestStatus::CANCELED, old_handler_status.status());

+ EXPECT_EQ(net::URLRequestStatus::CANCELED, new_handler_status.status());

} // namespace

} // namespace content