// Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include #include #include "base/macros.h" #include "base/memory/scoped_ptr.h" #include "base/memory/shared_memory.h" #include "base/message_loop/message_loop.h" #include "base/process/process_handle.h" #include "base/run_loop.h" #include "base/stl_util.h" #include "content/child/request_extra_data.h" #include "content/child/request_info.h" #include "content/child/resource_dispatcher.h" #include "content/common/appcache_interfaces.h" #include "content/common/resource_messages.h" #include "content/common/service_worker/service_worker_types.h" #include "content/public/child/request_peer.h" #include "content/public/common/resource_response.h" #include "net/base/net_errors.h" #include "net/http/http_response_headers.h" #include "testing/gtest/include/gtest/gtest.h" namespace content { static const char kTestPageUrl[] = "http://www.google.com/"; static const char kTestPageHeaders[] = "HTTP/1.1 200 OK\nContent-Type:text/html\n\n"; static const char kTestPageMimeType[] = "text/html"; static const char kTestPageCharset[] = ""; static const char kTestPageContents[] = "Google

Google

"; static const char kTestRedirectHeaders[] = "HTTP/1.1 302 Found\nLocation:http://www.google.com/\n\n"; // Listens for request response data and stores it so that it can be compared // to the reference data. class TestRequestPeer : public RequestPeer { public: TestRequestPeer(ResourceDispatcher* dispatcher) : follow_redirects_(true), defer_on_redirect_(false), seen_redirects_(0), cancel_on_receive_response_(false), received_response_(false), total_encoded_data_length_(0), total_downloaded_data_length_(0), complete_(false), dispatcher_(dispatcher), request_id_(0) { } void set_request_id(int request_id) { request_id_ = request_id; } void OnUploadProgress(uint64 position, uint64 size) override {} bool OnReceivedRedirect(const net::RedirectInfo& redirect_info, const ResourceResponseInfo& info) override { ++seen_redirects_; if (defer_on_redirect_) dispatcher_->SetDefersLoading(request_id_, true); return follow_redirects_; } void OnReceivedResponse(const ResourceResponseInfo& info) override { EXPECT_FALSE(received_response_); received_response_ = true; if (cancel_on_receive_response_) dispatcher_->Cancel(request_id_); } void OnDownloadedData(int len, int encoded_data_length) override { total_downloaded_data_length_ += len; total_encoded_data_length_ += encoded_data_length; } void OnReceivedData(const char* data, int data_length, int encoded_data_length) override { EXPECT_TRUE(received_response_); EXPECT_FALSE(complete_); data_.append(data, data_length); total_encoded_data_length_ += encoded_data_length; } void OnCompletedRequest(int error_code, bool was_ignored_by_handler, bool stale_copy_in_cache, const std::string& security_info, const base::TimeTicks& completion_time, int64 total_transfer_size) override { EXPECT_TRUE(received_response_); EXPECT_FALSE(complete_); complete_ = true; } void set_follow_redirects(bool follow_redirects) { follow_redirects_ = follow_redirects; } void set_defer_on_redirect(bool defer_on_redirect) { defer_on_redirect_ = defer_on_redirect; } void set_cancel_on_receive_response(bool cancel_on_receive_response) { cancel_on_receive_response_ = cancel_on_receive_response; } int seen_redirects() const { return seen_redirects_; } bool received_response() const { return received_response_; } const std::string& data() const { return data_; } int total_encoded_data_length() const { return total_encoded_data_length_; } int total_downloaded_data_length() const { return total_downloaded_data_length_; } bool complete() const { return complete_; } private: // True if should follow redirects, false if should cancel them. bool follow_redirects_; // True if the request should be deferred on redirects. bool defer_on_redirect_; // Number of total redirects seen. int seen_redirects_; bool cancel_on_receive_response_; bool received_response_; // Data received. If downloading to file, remains empty. std::string data_; // Total encoded data length, regardless of whether downloading to a file or // not. int total_encoded_data_length_; // Total length when downloading to a file. int total_downloaded_data_length_; bool complete_; ResourceDispatcher* dispatcher_; int request_id_; DISALLOW_COPY_AND_ASSIGN(TestRequestPeer); }; // Sets up the message sender override for the unit test. class ResourceDispatcherTest : public testing::Test, public IPC::Sender { public: ResourceDispatcherTest() : dispatcher_(this, message_loop_.task_runner()) {} ~ResourceDispatcherTest() override { STLDeleteContainerPairSecondPointers(shared_memory_map_.begin(), shared_memory_map_.end()); } // Emulates IPC send operations (IPC::Sender) by adding // pending messages to the queue. bool Send(IPC::Message* msg) override { message_queue_.push_back(IPC::Message(*msg)); delete msg; return true; } size_t queued_messages() const { return message_queue_.size(); } // Returns the ID of the consumed request. Can't make assumptions about the // ID, because numbering is based on a global. int ConsumeRequestResource() { if (message_queue_.empty()) { ADD_FAILURE() << "Missing resource request message"; return -1; } ResourceHostMsg_RequestResource::Param params; if (ResourceHostMsg_RequestResource::ID != message_queue_[0].type() || !ResourceHostMsg_RequestResource::Read(&message_queue_[0], ¶ms)) { ADD_FAILURE() << "Expected ResourceHostMsg_RequestResource message"; return -1; } ResourceHostMsg_Request request = get<2>(params); EXPECT_EQ(kTestPageUrl, request.url.spec()); message_queue_.erase(message_queue_.begin()); return get<1>(params); } void ConsumeFollowRedirect(int expected_request_id) { ASSERT_FALSE(message_queue_.empty()); Tuple args; ASSERT_EQ(ResourceHostMsg_FollowRedirect::ID, message_queue_[0].type()); ASSERT_TRUE(ResourceHostMsg_FollowRedirect::Read( &message_queue_[0], &args)); EXPECT_EQ(expected_request_id, get<0>(args)); message_queue_.erase(message_queue_.begin()); } void ConsumeDataReceived_ACK(int expected_request_id) { ASSERT_FALSE(message_queue_.empty()); Tuple args; ASSERT_EQ(ResourceHostMsg_DataReceived_ACK::ID, message_queue_[0].type()); ASSERT_TRUE(ResourceHostMsg_DataReceived_ACK::Read( &message_queue_[0], &args)); EXPECT_EQ(expected_request_id, get<0>(args)); message_queue_.erase(message_queue_.begin()); } void ConsumeDataDownloaded_ACK(int expected_request_id) { ASSERT_FALSE(message_queue_.empty()); Tuple args; ASSERT_EQ(ResourceHostMsg_DataDownloaded_ACK::ID, message_queue_[0].type()); ASSERT_TRUE(ResourceHostMsg_DataDownloaded_ACK::Read( &message_queue_[0], &args)); EXPECT_EQ(expected_request_id, get<0>(args)); message_queue_.erase(message_queue_.begin()); } void ConsumeReleaseDownloadedFile(int expected_request_id) { ASSERT_FALSE(message_queue_.empty()); Tuple args; ASSERT_EQ(ResourceHostMsg_ReleaseDownloadedFile::ID, message_queue_[0].type()); ASSERT_TRUE(ResourceHostMsg_ReleaseDownloadedFile::Read( &message_queue_[0], &args)); EXPECT_EQ(expected_request_id, get<0>(args)); message_queue_.erase(message_queue_.begin()); } void ConsumeCancelRequest(int expected_request_id) { ASSERT_FALSE(message_queue_.empty()); Tuple args; ASSERT_EQ(ResourceHostMsg_CancelRequest::ID, message_queue_[0].type()); ASSERT_TRUE(ResourceHostMsg_CancelRequest::Read( &message_queue_[0], &args)); EXPECT_EQ(expected_request_id, get<0>(args)); message_queue_.erase(message_queue_.begin()); } void NotifyReceivedRedirect(int request_id) { ResourceResponseHead head; std::string raw_headers(kTestRedirectHeaders); std::replace(raw_headers.begin(), raw_headers.end(), '\n', '\0'); head.headers = new net::HttpResponseHeaders(raw_headers); net::RedirectInfo redirect_info; redirect_info.status_code = 302; redirect_info.new_method = "GET"; redirect_info.new_url = GURL(kTestPageUrl); redirect_info.new_first_party_for_cookies = GURL(kTestPageUrl); EXPECT_EQ(true, dispatcher_.OnMessageReceived( ResourceMsg_ReceivedRedirect(request_id, redirect_info, head))); } void NotifyReceivedResponse(int request_id) { ResourceResponseHead head; std::string raw_headers(kTestPageHeaders); std::replace(raw_headers.begin(), raw_headers.end(), '\n', '\0'); head.headers = new net::HttpResponseHeaders(raw_headers); head.mime_type = kTestPageMimeType; head.charset = kTestPageCharset; EXPECT_EQ(true, dispatcher_.OnMessageReceived( ResourceMsg_ReceivedResponse(request_id, head))); } void NotifySetDataBuffer(int request_id, size_t buffer_size) { base::SharedMemory* shared_memory = new base::SharedMemory(); ASSERT_FALSE(shared_memory_map_[request_id]); shared_memory_map_[request_id] = shared_memory; EXPECT_TRUE(shared_memory->CreateAndMapAnonymous(buffer_size)); base::SharedMemoryHandle duplicate_handle; EXPECT_TRUE(shared_memory->ShareToProcess(base::GetCurrentProcessHandle(), &duplicate_handle)); EXPECT_TRUE(dispatcher_.OnMessageReceived( ResourceMsg_SetDataBuffer(request_id, duplicate_handle, shared_memory->requested_size(), 0))); } void NotifyDataReceived(int request_id, std::string data) { ASSERT_LE(data.length(), shared_memory_map_[request_id]->requested_size()); memcpy(shared_memory_map_[request_id]->memory(), data.c_str(), data.length()); EXPECT_TRUE(dispatcher_.OnMessageReceived( ResourceMsg_DataReceived(request_id, 0, data.length(), data.length()))); } void NotifyDataDownloaded(int request_id, int decoded_length, int encoded_length) { EXPECT_TRUE(dispatcher_.OnMessageReceived( ResourceMsg_DataDownloaded(request_id, decoded_length, encoded_length))); } void NotifyRequestComplete(int request_id, size_t total_size) { ResourceMsg_RequestCompleteData request_complete_data; request_complete_data.error_code = net::OK; request_complete_data.was_ignored_by_handler = false; request_complete_data.exists_in_cache = false; request_complete_data.encoded_data_length = total_size; EXPECT_TRUE(dispatcher_.OnMessageReceived( ResourceMsg_RequestComplete(request_id, request_complete_data))); } RequestInfo* CreateRequestInfo(bool download_to_file) { RequestInfo* request_info = new RequestInfo(); request_info->method = "GET"; request_info->url = GURL(kTestPageUrl); request_info->first_party_for_cookies = GURL(kTestPageUrl); request_info->referrer = Referrer(); request_info->headers = std::string(); request_info->load_flags = 0; request_info->requestor_pid = 0; request_info->request_type = RESOURCE_TYPE_SUB_RESOURCE; request_info->appcache_host_id = kAppCacheNoHostId; request_info->should_reset_appcache = false; request_info->routing_id = 0; request_info->download_to_file = download_to_file; RequestExtraData extra_data; return request_info; } ResourceDispatcher* dispatcher() { return &dispatcher_; } private: // Map of request IDs to shared memory. std::map shared_memory_map_; std::vector message_queue_; base::MessageLoop message_loop_; ResourceDispatcher dispatcher_; }; // Does a simple request and tests that the correct data is received. Simulates // two reads. TEST_F(ResourceDispatcherTest, RoundTrip) { // Number of bytes received in the first read. const size_t kFirstReceiveSize = 2; ASSERT_LT(kFirstReceiveSize, strlen(kTestPageContents)); scoped_ptr request_info(CreateRequestInfo(false)); TestRequestPeer peer(dispatcher()); int request_id = dispatcher()->StartAsync(*request_info.get(), NULL, &peer); peer.set_request_id(request_id); int id = ConsumeRequestResource(); EXPECT_EQ(0u, queued_messages()); NotifyReceivedResponse(id); EXPECT_EQ(0u, queued_messages()); EXPECT_TRUE(peer.received_response()); NotifySetDataBuffer(id, strlen(kTestPageContents)); NotifyDataReceived(id, std::string(kTestPageContents, kFirstReceiveSize)); ConsumeDataReceived_ACK(id); EXPECT_EQ(0u, queued_messages()); NotifyDataReceived(id, kTestPageContents + kFirstReceiveSize); ConsumeDataReceived_ACK(id); EXPECT_EQ(0u, queued_messages()); NotifyRequestComplete(id, strlen(kTestPageContents)); EXPECT_EQ(kTestPageContents, peer.data()); EXPECT_TRUE(peer.complete()); EXPECT_EQ(0u, queued_messages()); } // Tests that the request IDs are straight when there are two interleaving // requests. TEST_F(ResourceDispatcherTest, MultipleRequests) { const char kTestPageContents2[] = "Not kTestPageContents"; scoped_ptr request_info1(CreateRequestInfo(false)); TestRequestPeer peer1(dispatcher()); int request_id1 = dispatcher()->StartAsync( *request_info1.get(), NULL, &peer1); peer1.set_request_id(request_id1); scoped_ptr request_info2(CreateRequestInfo(false)); TestRequestPeer peer2(dispatcher()); int request_id2 = dispatcher()->StartAsync( *request_info1.get(), NULL, &peer2); peer2.set_request_id(request_id2); int id1 = ConsumeRequestResource(); int id2 = ConsumeRequestResource(); EXPECT_EQ(0u, queued_messages()); NotifyReceivedResponse(id1); EXPECT_TRUE(peer1.received_response()); EXPECT_FALSE(peer2.received_response()); NotifyReceivedResponse(id2); EXPECT_TRUE(peer2.received_response()); EXPECT_EQ(0u, queued_messages()); NotifySetDataBuffer(id2, strlen(kTestPageContents2)); NotifyDataReceived(id2, kTestPageContents2); ConsumeDataReceived_ACK(id2); NotifySetDataBuffer(id1, strlen(kTestPageContents)); NotifyDataReceived(id1, kTestPageContents); ConsumeDataReceived_ACK(id1); EXPECT_EQ(0u, queued_messages()); NotifyRequestComplete(id1, strlen(kTestPageContents)); EXPECT_EQ(kTestPageContents, peer1.data()); EXPECT_TRUE(peer1.complete()); EXPECT_FALSE(peer2.complete()); NotifyRequestComplete(id2, strlen(kTestPageContents2)); EXPECT_EQ(kTestPageContents2, peer2.data()); EXPECT_TRUE(peer2.complete()); EXPECT_EQ(0u, queued_messages()); } // Tests that the cancel method prevents other messages from being received. TEST_F(ResourceDispatcherTest, Cancel) { scoped_ptr request_info(CreateRequestInfo(false)); TestRequestPeer peer(dispatcher()); int request_id = dispatcher()->StartAsync(*request_info.get(), NULL, &peer); peer.set_request_id(request_id); int id = ConsumeRequestResource(); EXPECT_EQ(0u, queued_messages()); // Cancel the request. dispatcher()->Cancel(request_id); ConsumeCancelRequest(id); // Any future messages related to the request should be ignored. NotifyReceivedResponse(id); NotifySetDataBuffer(id, strlen(kTestPageContents)); NotifyDataReceived(id, kTestPageContents); NotifyRequestComplete(id, strlen(kTestPageContents)); EXPECT_EQ(0u, queued_messages()); EXPECT_EQ("", peer.data()); EXPECT_FALSE(peer.received_response()); EXPECT_FALSE(peer.complete()); } // Tests that calling cancel during a callback works as expected. TEST_F(ResourceDispatcherTest, CancelDuringCallback) { scoped_ptr request_info(CreateRequestInfo(false)); TestRequestPeer peer(dispatcher()); int request_id = dispatcher()->StartAsync(*request_info.get(), NULL, &peer); peer.set_request_id(request_id); peer.set_cancel_on_receive_response(true); int id = ConsumeRequestResource(); EXPECT_EQ(0u, queued_messages()); NotifyReceivedResponse(id); EXPECT_TRUE(peer.received_response()); // Request should have been cancelled. ConsumeCancelRequest(id); // Any future messages related to the request should be ignored. NotifySetDataBuffer(id, strlen(kTestPageContents)); NotifyDataReceived(id, kTestPageContents); NotifyRequestComplete(id, strlen(kTestPageContents)); EXPECT_EQ(0u, queued_messages()); EXPECT_EQ("", peer.data()); EXPECT_FALSE(peer.complete()); } // Checks that redirects work as expected. TEST_F(ResourceDispatcherTest, Redirect) { scoped_ptr request_info(CreateRequestInfo(false)); TestRequestPeer peer(dispatcher()); int request_id = dispatcher()->StartAsync(*request_info.get(), NULL, &peer); peer.set_request_id(request_id); int id = ConsumeRequestResource(); NotifyReceivedRedirect(id); ConsumeFollowRedirect(id); EXPECT_EQ(1, peer.seen_redirects()); NotifyReceivedRedirect(id); ConsumeFollowRedirect(id); EXPECT_EQ(2, peer.seen_redirects()); NotifyReceivedResponse(id); EXPECT_TRUE(peer.received_response()); NotifySetDataBuffer(id, strlen(kTestPageContents)); NotifyDataReceived(id, kTestPageContents); ConsumeDataReceived_ACK(id); NotifyRequestComplete(id, strlen(kTestPageContents)); EXPECT_EQ(kTestPageContents, peer.data()); EXPECT_TRUE(peer.complete()); EXPECT_EQ(0u, queued_messages()); EXPECT_EQ(2, peer.seen_redirects()); } // Tests that that cancelling during a redirect method prevents other messages // from being received. TEST_F(ResourceDispatcherTest, CancelDuringRedirect) { scoped_ptr request_info(CreateRequestInfo(false)); TestRequestPeer peer(dispatcher()); int request_id = dispatcher()->StartAsync(*request_info.get(), NULL, &peer); peer.set_request_id(request_id); peer.set_follow_redirects(false); int id = ConsumeRequestResource(); EXPECT_EQ(0u, queued_messages()); // Redirect the request, which triggers a cancellation. NotifyReceivedRedirect(id); ConsumeCancelRequest(id); EXPECT_EQ(1, peer.seen_redirects()); EXPECT_EQ(0u, queued_messages()); // Any future messages related to the request should be ignored. In practice, // only the NotifyRequestComplete should be received after this point. NotifyReceivedRedirect(id); NotifyReceivedResponse(id); NotifySetDataBuffer(id, strlen(kTestPageContents)); NotifyDataReceived(id, kTestPageContents); NotifyRequestComplete(id, strlen(kTestPageContents)); EXPECT_EQ(0u, queued_messages()); EXPECT_EQ("", peer.data()); EXPECT_FALSE(peer.complete()); EXPECT_EQ(1, peer.seen_redirects()); } // Checks that deferring a request delays messages until it's resumed. TEST_F(ResourceDispatcherTest, Defer) { scoped_ptr request_info(CreateRequestInfo(false)); TestRequestPeer peer(dispatcher()); int request_id = dispatcher()->StartAsync(*request_info.get(), NULL, &peer); peer.set_request_id(request_id); int id = ConsumeRequestResource(); EXPECT_EQ(0u, queued_messages()); dispatcher()->SetDefersLoading(request_id, true); NotifyReceivedResponse(id); NotifySetDataBuffer(id, strlen(kTestPageContents)); NotifyDataReceived(id, kTestPageContents); NotifyRequestComplete(id, strlen(kTestPageContents)); // None of the messages should have been processed yet, so no queued messages // to the browser process, and no data received by the peer. EXPECT_EQ(0u, queued_messages()); EXPECT_EQ("", peer.data()); EXPECT_FALSE(peer.complete()); EXPECT_EQ(0, peer.seen_redirects()); // Resuming the request should asynchronously unleash the deferred messages. dispatcher()->SetDefersLoading(request_id, false); base::RunLoop().RunUntilIdle(); ConsumeDataReceived_ACK(id); EXPECT_EQ(0u, queued_messages()); EXPECT_TRUE(peer.received_response()); EXPECT_EQ(kTestPageContents, peer.data()); EXPECT_TRUE(peer.complete()); } // Checks that deferring a request during a redirect delays messages until it's // resumed. TEST_F(ResourceDispatcherTest, DeferOnRedirect) { scoped_ptr request_info(CreateRequestInfo(false)); TestRequestPeer peer(dispatcher()); int request_id = dispatcher()->StartAsync(*request_info.get(), NULL, &peer); peer.set_request_id(request_id); peer.set_defer_on_redirect(true); int id = ConsumeRequestResource(); EXPECT_EQ(0u, queued_messages()); // The request should be deferred during the redirect, including the message // to follow the redirect. NotifyReceivedRedirect(id); NotifyReceivedResponse(id); NotifySetDataBuffer(id, strlen(kTestPageContents)); NotifyDataReceived(id, kTestPageContents); NotifyRequestComplete(id, strlen(kTestPageContents)); // None of the messages should have been processed yet, so no queued messages // to the browser process, and no data received by the peer. EXPECT_EQ(0u, queued_messages()); EXPECT_EQ("", peer.data()); EXPECT_FALSE(peer.complete()); EXPECT_EQ(1, peer.seen_redirects()); // Resuming the request should asynchronously unleash the deferred messages. dispatcher()->SetDefersLoading(request_id, false); base::RunLoop().RunUntilIdle(); ConsumeFollowRedirect(id); ConsumeDataReceived_ACK(id); EXPECT_EQ(0u, queued_messages()); EXPECT_TRUE(peer.received_response()); EXPECT_EQ(kTestPageContents, peer.data()); EXPECT_TRUE(peer.complete()); EXPECT_EQ(1, peer.seen_redirects()); } // Checks that a deferred request that's cancelled doesn't receive any messages. TEST_F(ResourceDispatcherTest, CancelDeferredRequest) { scoped_ptr request_info(CreateRequestInfo(false)); TestRequestPeer peer(dispatcher()); int request_id = dispatcher()->StartAsync(*request_info.get(), NULL, &peer); peer.set_request_id(request_id); int id = ConsumeRequestResource(); EXPECT_EQ(0u, queued_messages()); dispatcher()->SetDefersLoading(request_id, true); NotifyReceivedRedirect(id); dispatcher()->Cancel(request_id); ConsumeCancelRequest(id); NotifyRequestComplete(id, 0); base::RunLoop().RunUntilIdle(); // None of the messages should have been processed. EXPECT_EQ(0u, queued_messages()); EXPECT_EQ("", peer.data()); EXPECT_FALSE(peer.complete()); EXPECT_EQ(0, peer.seen_redirects()); } TEST_F(ResourceDispatcherTest, DownloadToFile) { scoped_ptr request_info(CreateRequestInfo(true)); TestRequestPeer peer(dispatcher()); int request_id = dispatcher()->StartAsync(*request_info.get(), NULL, &peer); peer.set_request_id(request_id); const int kDownloadedIncrement = 100; const int kEncodedIncrement = 50; int id = ConsumeRequestResource(); EXPECT_EQ(0u, queued_messages()); NotifyReceivedResponse(id); EXPECT_EQ(0u, queued_messages()); EXPECT_TRUE(peer.received_response()); int expected_total_downloaded_length = 0; int expected_total_encoded_length = 0; for (int i = 0; i < 10; ++i) { NotifyDataDownloaded(id, kDownloadedIncrement, kEncodedIncrement); ConsumeDataDownloaded_ACK(id); expected_total_downloaded_length += kDownloadedIncrement; expected_total_encoded_length += kEncodedIncrement; EXPECT_EQ(expected_total_downloaded_length, peer.total_downloaded_data_length()); EXPECT_EQ(expected_total_encoded_length, peer.total_encoded_data_length()); } NotifyRequestComplete(id, strlen(kTestPageContents)); EXPECT_EQ("", peer.data()); EXPECT_TRUE(peer.complete()); EXPECT_EQ(0u, queued_messages()); dispatcher()->RemovePendingRequest(request_id); ConsumeReleaseDownloadedFile(id); EXPECT_EQ(0u, queued_messages()); EXPECT_EQ(expected_total_downloaded_length, peer.total_downloaded_data_length()); EXPECT_EQ(expected_total_encoded_length, peer.total_encoded_data_length()); } // Make sure that when a download to file is cancelled, the file is destroyed. TEST_F(ResourceDispatcherTest, CancelDownloadToFile) { scoped_ptr request_info(CreateRequestInfo(true)); TestRequestPeer peer(dispatcher()); int request_id = dispatcher()->StartAsync(*request_info.get(), NULL, &peer); peer.set_request_id(request_id); int id = ConsumeRequestResource(); EXPECT_EQ(0u, queued_messages()); NotifyReceivedResponse(id); EXPECT_EQ(0u, queued_messages()); EXPECT_TRUE(peer.received_response()); // Cancelling the request deletes the file. dispatcher()->Cancel(request_id); ConsumeCancelRequest(id); ConsumeReleaseDownloadedFile(id); } TEST_F(ResourceDispatcherTest, Cookies) { // FIXME } TEST_F(ResourceDispatcherTest, SerializedPostData) { // FIXME } class TimeConversionTest : public ResourceDispatcherTest, public RequestPeer { public: bool Send(IPC::Message* msg) override { delete msg; return true; } void PerformTest(const ResourceResponseHead& response_head) { scoped_ptr request_info(CreateRequestInfo(false)); TestRequestPeer peer(dispatcher()); dispatcher()->StartAsync(*request_info.get(), NULL, &peer); dispatcher()->OnMessageReceived( ResourceMsg_ReceivedResponse(0, response_head)); } // RequestPeer methods. void OnUploadProgress(uint64 position, uint64 size) override {} bool OnReceivedRedirect(const net::RedirectInfo& redirect_info, const ResourceResponseInfo& info) override { return true; } void OnReceivedResponse(const ResourceResponseInfo& info) override { response_info_ = info; } void OnDownloadedData(int len, int encoded_data_length) override {} void OnReceivedData(const char* data, int data_length, int encoded_data_length) override {} void OnCompletedRequest(int error_code, bool was_ignored_by_handler, bool stale_copy_in_cache, const std::string& security_info, const base::TimeTicks& completion_time, int64 total_transfer_size) override {} const ResourceResponseInfo& response_info() const { return response_info_; } private: ResourceResponseInfo response_info_; }; // TODO(simonjam): Enable this when 10829031 lands. TEST_F(TimeConversionTest, DISABLED_ProperlyInitialized) { ResourceResponseHead response_head; response_head.request_start = base::TimeTicks::FromInternalValue(5); response_head.response_start = base::TimeTicks::FromInternalValue(15); response_head.load_timing.request_start_time = base::Time::Now(); response_head.load_timing.request_start = base::TimeTicks::FromInternalValue(10); response_head.load_timing.connect_timing.connect_start = base::TimeTicks::FromInternalValue(13); PerformTest(response_head); EXPECT_LT(base::TimeTicks(), response_info().load_timing.request_start); EXPECT_EQ(base::TimeTicks(), response_info().load_timing.connect_timing.dns_start); EXPECT_LE(response_head.load_timing.request_start, response_info().load_timing.connect_timing.connect_start); } TEST_F(TimeConversionTest, PartiallyInitialized) { ResourceResponseHead response_head; response_head.request_start = base::TimeTicks::FromInternalValue(5); response_head.response_start = base::TimeTicks::FromInternalValue(15); PerformTest(response_head); EXPECT_EQ(base::TimeTicks(), response_info().load_timing.request_start); EXPECT_EQ(base::TimeTicks(), response_info().load_timing.connect_timing.dns_start); } TEST_F(TimeConversionTest, NotInitialized) { ResourceResponseHead response_head; PerformTest(response_head); EXPECT_EQ(base::TimeTicks(), response_info().load_timing.request_start); EXPECT_EQ(base::TimeTicks(), response_info().load_timing.connect_timing.dns_start); } } // namespace content