Google Git
Sign in
chromium / chromium / src.git / 591d4f67e37eadf911c0fee80a1d414c9602aaaf / . / content / child / resource_dispatcher_unittest.cc
blob: 1b3e0a7a575486c6bc0ddcf321d800be8b12f836 [file] [log] [blame]
[email protected]80744782012-05-04 01:47:00[diff] [blame]1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
license.botbf09a502008-08-24 00:55:55[diff] [blame]2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]4
dchengf63a1252015-12-26 20:43:13[diff] [blame]5#include "content/child/resource_dispatcher.h"
6
avi66a07722015-12-25 23:38:12[diff] [blame]7#include <stddef.h>
8#include <stdint.h>
dchengc864f522016-04-08 23:55:27[diff] [blame]9
10#include <memory>
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]11#include <string>
tzik1068f1be2016-06-03 07:25:20[diff] [blame]12#include <tuple>
dchengf63a1252015-12-26 20:43:13[diff] [blame]13#include <utility>
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]14#include <vector>
15
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]16#include "base/macros.h"
dchengc864f522016-04-08 23:55:27[diff] [blame]17#include "base/memory/ptr_util.h"
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]18#include "base/memory/shared_memory.h"
[email protected]e55f5642013-07-18 00:22:54[diff] [blame]19#include "base/message_loop/message_loop.h"
[email protected]54724e22013-07-25 13:02:15[diff] [blame]20#include "base/process/process_handle.h"
[email protected]2a1a06d2014-06-04 12:24:36[diff] [blame]21#include "base/run_loop.h"
asvitkineb1db8262016-11-08 09:48:20[diff] [blame]22#include "base/test/scoped_feature_list.h"
[email protected]541b7b02013-06-07 00:59:34[diff] [blame]23#include "content/child/request_extra_data.h"
yhiranof6c76cf2016-12-22 11:42:18[diff] [blame]24#include "content/child/test_request_peer.h"
[email protected]98d6d4562014-06-25 20:57:55[diff] [blame]25#include "content/common/appcache_interfaces.h"
[email protected]94dc971d2011-03-05 19:08:32[diff] [blame]26#include "content/common/resource_messages.h"
yhirano20c94ea9b2016-05-18 05:20:45[diff] [blame]27#include "content/common/resource_request.h"
28#include "content/common/resource_request_completion_status.h"
[email protected]fa07f6572014-03-06 13:10:10[diff] [blame]29#include "content/common/service_worker/service_worker_types.h"
kinuko5e4122a22016-02-09 02:38:24[diff] [blame]30#include "content/public/child/fixed_received_data.h"
[email protected]ddf55bb2014-04-03 08:24:47[diff] [blame]31#include "content/public/child/request_peer.h"
kinuko5e4122a22016-02-09 02:38:24[diff] [blame]32#include "content/public/child/resource_dispatcher_delegate.h"
riceae7b920b2016-07-13 04:22:00[diff] [blame]33#include "content/public/common/content_features.h"
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]34#include "content/public/common/request_context_frame_type.h"
[email protected]2336ffe2011-11-24 01:23:34[diff] [blame]35#include "content/public/common/resource_response.h"
[email protected]2756a8e2012-09-07 18:24:29[diff] [blame]36#include "net/base/net_errors.h"
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]37#include "net/base/request_priority.h"
[email protected]7a4de7a62010-08-17 18:38:24[diff] [blame]38#include "net/http/http_response_headers.h"
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]39#include "testing/gtest/include/gtest/gtest.h"
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]40#include "third_party/WebKit/public/platform/WebReferrerPolicy.h"
41#include "url/gurl.h"
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]42
[email protected]be7b41e82012-07-04 09:46:51[diff] [blame]43namespace content {
44
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]45static const char kTestPageUrl[] = "http://www.google.com/";
46static const char kTestPageHeaders[] =
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]47 "HTTP/1.1 200 OK\nContent-Type:text/html\n\n";
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]48static const char kTestPageMimeType[] = "text/html";
49static const char kTestPageCharset[] = "";
50static const char kTestPageContents[] =
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]51 "<html><head><title>Google</title></head><body><h1>Google</h1></body></html>";
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]52static const char kTestRedirectHeaders[] =
53 "HTTP/1.1 302 Found\nLocation:http://www.google.com/\n\n";
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]54
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]55// Sets up the message sender override for the unit test.
[email protected]d84effeb2012-06-25 17:03:10[diff] [blame]56class ResourceDispatcherTest : public testing::Test, public IPC::Sender {
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]57 public:
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]58 ResourceDispatcherTest()
59 : dispatcher_(new ResourceDispatcher(this, message_loop_.task_runner())) {
60 }
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]61
dchengf5762152014-10-29 02:12:06[diff] [blame]62 ~ResourceDispatcherTest() override {
avi82554752016-09-23 17:48:50[diff] [blame]63 shared_memory_map_.clear();
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]64 dispatcher_.reset();
65 base::RunLoop().RunUntilIdle();
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]66 }
67
[email protected]d84effeb2012-06-25 17:03:10[diff] [blame]68 // Emulates IPC send operations (IPC::Sender) by adding
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]69 // pending messages to the queue.
dchenge933b3e2014-10-21 11:44:09[diff] [blame]70 bool Send(IPC::Message* msg) override {
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]71 message_queue_.push_back(IPC::Message(*msg));
72 delete msg;
73 return true;
74 }
75
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]76 size_t queued_messages() const { return message_queue_.size(); }
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]77
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]78 // Returns the ID of the consumed request. Can't make assumptions about the
79 // ID, because numbering is based on a global.
80 int ConsumeRequestResource() {
81 if (message_queue_.empty()) {
82 ADD_FAILURE() << "Missing resource request message";
83 return -1;
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]84 }
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]85
86 ResourceHostMsg_RequestResource::Param params;
87 if (ResourceHostMsg_RequestResource::ID != message_queue_[0].type() ||
88 !ResourceHostMsg_RequestResource::Read(&message_queue_[0], &params)) {
89 ADD_FAILURE() << "Expected ResourceHostMsg_RequestResource message";
90 return -1;
91 }
tzik1068f1be2016-06-03 07:25:20[diff] [blame]92 ResourceRequest request = std::get<2>(params);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]93 EXPECT_EQ(kTestPageUrl, request.url.spec());
94 message_queue_.erase(message_queue_.begin());
tzik1068f1be2016-06-03 07:25:20[diff] [blame]95 return std::get<1>(params);
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]96 }
97
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]98 void ConsumeFollowRedirect(int expected_request_id) {
99 ASSERT_FALSE(message_queue_.empty());
tzik1068f1be2016-06-03 07:25:20[diff] [blame]100 std::tuple<int> args;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]101 ASSERT_EQ(ResourceHostMsg_FollowRedirect::ID, message_queue_[0].type());
102 ASSERT_TRUE(ResourceHostMsg_FollowRedirect::Read(
103 &message_queue_[0], &args));
tzik1068f1be2016-06-03 07:25:20[diff] [blame]104 EXPECT_EQ(expected_request_id, std::get<0>(args));
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]105 message_queue_.erase(message_queue_.begin());
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]106 }
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]107
108 void ConsumeDataReceived_ACK(int expected_request_id) {
109 ASSERT_FALSE(message_queue_.empty());
tzik1068f1be2016-06-03 07:25:20[diff] [blame]110 std::tuple<int> args;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]111 ASSERT_EQ(ResourceHostMsg_DataReceived_ACK::ID, message_queue_[0].type());
112 ASSERT_TRUE(ResourceHostMsg_DataReceived_ACK::Read(
113 &message_queue_[0], &args));
tzik1068f1be2016-06-03 07:25:20[diff] [blame]114 EXPECT_EQ(expected_request_id, std::get<0>(args));
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]115 message_queue_.erase(message_queue_.begin());
116 }
117
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]118 void ConsumeReleaseDownloadedFile(int expected_request_id) {
119 ASSERT_FALSE(message_queue_.empty());
tzik1068f1be2016-06-03 07:25:20[diff] [blame]120 std::tuple<int> args;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]121 ASSERT_EQ(ResourceHostMsg_ReleaseDownloadedFile::ID,
122 message_queue_[0].type());
123 ASSERT_TRUE(ResourceHostMsg_ReleaseDownloadedFile::Read(
124 &message_queue_[0], &args));
tzik1068f1be2016-06-03 07:25:20[diff] [blame]125 EXPECT_EQ(expected_request_id, std::get<0>(args));
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]126 message_queue_.erase(message_queue_.begin());
127 }
128
129 void ConsumeCancelRequest(int expected_request_id) {
130 ASSERT_FALSE(message_queue_.empty());
tzik1068f1be2016-06-03 07:25:20[diff] [blame]131 std::tuple<int> args;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]132 ASSERT_EQ(ResourceHostMsg_CancelRequest::ID, message_queue_[0].type());
133 ASSERT_TRUE(ResourceHostMsg_CancelRequest::Read(
134 &message_queue_[0], &args));
tzik1068f1be2016-06-03 07:25:20[diff] [blame]135 EXPECT_EQ(expected_request_id, std::get<0>(args));
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]136 message_queue_.erase(message_queue_.begin());
137 }
138
139 void NotifyReceivedRedirect(int request_id) {
140 ResourceResponseHead head;
141 std::string raw_headers(kTestRedirectHeaders);
142 std::replace(raw_headers.begin(), raw_headers.end(), '\n', '\0');
143 head.headers = new net::HttpResponseHeaders(raw_headers);
[email protected]cba24642014-08-15 20:49:59[diff] [blame]144 net::RedirectInfo redirect_info;
145 redirect_info.status_code = 302;
146 redirect_info.new_method = "GET";
147 redirect_info.new_url = GURL(kTestPageUrl);
148 redirect_info.new_first_party_for_cookies = GURL(kTestPageUrl);
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]149 EXPECT_EQ(true, dispatcher_->OnMessageReceived(ResourceMsg_ReceivedRedirect(
150 request_id, redirect_info, head)));
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]151 }
152
153 void NotifyReceivedResponse(int request_id) {
154 ResourceResponseHead head;
155 std::string raw_headers(kTestPageHeaders);
156 std::replace(raw_headers.begin(), raw_headers.end(), '\n', '\0');
157 head.headers = new net::HttpResponseHeaders(raw_headers);
158 head.mime_type = kTestPageMimeType;
159 head.charset = kTestPageCharset;
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]160 EXPECT_EQ(true, dispatcher_->OnMessageReceived(
161 ResourceMsg_ReceivedResponse(request_id, head)));
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]162 }
163
164 void NotifySetDataBuffer(int request_id, size_t buffer_size) {
165 base::SharedMemory* shared_memory = new base::SharedMemory();
166 ASSERT_FALSE(shared_memory_map_[request_id]);
avi82554752016-09-23 17:48:50[diff] [blame]167 shared_memory_map_[request_id] = base::WrapUnique(shared_memory);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]168 EXPECT_TRUE(shared_memory->CreateAndMapAnonymous(buffer_size));
169
erikchen37e7d8302017-05-03 04:05:02[diff] [blame]170 base::SharedMemoryHandle duplicate_handle =
171 shared_memory->handle().Duplicate();
172 EXPECT_TRUE(duplicate_handle.IsValid());
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]173 EXPECT_TRUE(dispatcher_->OnMessageReceived(ResourceMsg_SetDataBuffer(
174 request_id, duplicate_handle, shared_memory->requested_size(), 0)));
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]175 }
176
ki.stfu7cf10ca2015-09-27 08:37:01[diff] [blame]177 void NotifyDataReceived(int request_id, const std::string& data) {
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]178 ASSERT_LE(data.length(), shared_memory_map_[request_id]->requested_size());
179 memcpy(shared_memory_map_[request_id]->memory(), data.c_str(),
180 data.length());
181
riceae7b920b2016-07-13 04:22:00[diff] [blame]182 EXPECT_TRUE(dispatcher_->OnMessageReceived(ResourceMsg_DataReceived(
yhiranoce1c79962016-11-28 17:58:35[diff] [blame]183 request_id, 0, data.length(), data.length())));
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]184 }
185
riceae7b920b2016-07-13 04:22:00[diff] [blame]186 void NotifyDataDownloaded(int request_id,
187 int decoded_length,
ricead91ea732016-07-20 12:53:28[diff] [blame]188 int encoded_data_length) {
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]189 EXPECT_TRUE(dispatcher_->OnMessageReceived(ResourceMsg_DataDownloaded(
ricead91ea732016-07-20 12:53:28[diff] [blame]190 request_id, decoded_length, encoded_data_length)));
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]191 }
192
193 void NotifyRequestComplete(int request_id, size_t total_size) {
yhirano20c94ea9b2016-05-18 05:20:45[diff] [blame]194 ResourceRequestCompletionStatus request_complete_data;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]195 request_complete_data.error_code = net::OK;
196 request_complete_data.was_ignored_by_handler = false;
197 request_complete_data.exists_in_cache = false;
198 request_complete_data.encoded_data_length = total_size;
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]199 EXPECT_TRUE(dispatcher_->OnMessageReceived(
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]200 ResourceMsg_RequestComplete(request_id, request_complete_data)));
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]201 }
202
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]203 std::unique_ptr<ResourceRequest> CreateResourceRequest(
204 bool download_to_file) {
205 std::unique_ptr<ResourceRequest> request(new ResourceRequest());
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]206
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]207 request->method = "GET";
208 request->url = GURL(kTestPageUrl);
209 request->first_party_for_cookies = GURL(kTestPageUrl);
Blink Reformat1c4d759e2017-04-09 16:34:54[diff] [blame]210 request->referrer_policy = blink::kWebReferrerPolicyDefault;
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]211 request->resource_type = RESOURCE_TYPE_SUB_RESOURCE;
212 request->priority = net::LOW;
213 request->fetch_request_mode = FETCH_REQUEST_MODE_NO_CORS;
214 request->fetch_frame_type = REQUEST_CONTEXT_FRAME_TYPE_NONE;
215 request->download_to_file = download_to_file;
216
217 const RequestExtraData extra_data;
218 extra_data.CopyToResourceRequest(request.get());
219
220 return request;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]221 }
222
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]223 ResourceDispatcher* dispatcher() { return dispatcher_.get(); }
224
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]225 int StartAsync(std::unique_ptr<ResourceRequest> request,
lukaszade802372016-06-16 17:17:23[diff] [blame]226 ResourceRequestBodyImpl* request_body,
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]227 TestRequestPeer::Context* peer_context) {
dchengc864f522016-04-08 23:55:27[diff] [blame]228 std::unique_ptr<TestRequestPeer> peer(
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]229 new TestRequestPeer(dispatcher(), peer_context));
yhirano72f62272016-08-13 12:50:06[diff] [blame]230 int request_id = dispatcher()->StartAsync(
csharrisonf32ade752016-12-08 22:49:56[diff] [blame]231 std::move(request), 0, nullptr, url::Origin(), std::move(peer),
scottmgefb697302017-04-12 22:37:30[diff] [blame]232 blink::WebURLRequest::LoadingIPCType::kChromeIPC, nullptr,
yzshen2d8fb422017-06-01 20:29:40[diff] [blame]233 std::vector<std::unique_ptr<URLLoaderThrottle>>(),
scottmgefb697302017-04-12 22:37:30[diff] [blame]234 mojo::ScopedDataPipeConsumerHandle());
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]235 peer_context->request_id = request_id;
236 return request_id;
237 }
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]238
239 private:
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]240 // Map of request IDs to shared memory.
avi82554752016-09-23 17:48:50[diff] [blame]241 std::map<int, std::unique_ptr<base::SharedMemory>> shared_memory_map_;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]242
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]243 std::vector<IPC::Message> message_queue_;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]244 base::MessageLoop message_loop_;
dchengc864f522016-04-08 23:55:27[diff] [blame]245 std::unique_ptr<ResourceDispatcher> dispatcher_;
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]246};
247
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]248// Does a simple request and tests that the correct data is received. Simulates
249// two reads.
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]250TEST_F(ResourceDispatcherTest, RoundTrip) {
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]251 // Number of bytes received in the first read.
252 const size_t kFirstReceiveSize = 2;
253 ASSERT_LT(kFirstReceiveSize, strlen(kTestPageContents));
254
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]255 std::unique_ptr<ResourceRequest> request(CreateResourceRequest(false));
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]256 TestRequestPeer::Context peer_context;
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]257 StartAsync(std::move(request), NULL, &peer_context);
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]258
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]259 int id = ConsumeRequestResource();
260 EXPECT_EQ(0u, queued_messages());
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]261
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]262 NotifyReceivedResponse(id);
263 EXPECT_EQ(0u, queued_messages());
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]264 EXPECT_TRUE(peer_context.received_response);
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]265
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]266 NotifySetDataBuffer(id, strlen(kTestPageContents));
267 NotifyDataReceived(id, std::string(kTestPageContents, kFirstReceiveSize));
268 ConsumeDataReceived_ACK(id);
269 EXPECT_EQ(0u, queued_messages());
270
271 NotifyDataReceived(id, kTestPageContents + kFirstReceiveSize);
272 ConsumeDataReceived_ACK(id);
273 EXPECT_EQ(0u, queued_messages());
274
275 NotifyRequestComplete(id, strlen(kTestPageContents));
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]276 EXPECT_EQ(kTestPageContents, peer_context.data);
277 EXPECT_TRUE(peer_context.complete);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]278 EXPECT_EQ(0u, queued_messages());
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]279}
280
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]281// Tests that the request IDs are straight when there are two interleaving
282// requests.
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]283TEST_F(ResourceDispatcherTest, MultipleRequests) {
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]284 const char kTestPageContents2[] = "Not kTestPageContents";
285
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]286 std::unique_ptr<ResourceRequest> request1(CreateResourceRequest(false));
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]287 TestRequestPeer::Context peer_context1;
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]288 StartAsync(std::move(request1), NULL, &peer_context1);
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]289
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]290 std::unique_ptr<ResourceRequest> request2(CreateResourceRequest(false));
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]291 TestRequestPeer::Context peer_context2;
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]292 StartAsync(std::move(request2), NULL, &peer_context2);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]293
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]294 int id1 = ConsumeRequestResource();
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]295 int id2 = ConsumeRequestResource();
296 EXPECT_EQ(0u, queued_messages());
297
298 NotifyReceivedResponse(id1);
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]299 EXPECT_TRUE(peer_context1.received_response);
300 EXPECT_FALSE(peer_context2.received_response);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]301 NotifyReceivedResponse(id2);
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]302 EXPECT_TRUE(peer_context2.received_response);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]303 EXPECT_EQ(0u, queued_messages());
304
305 NotifySetDataBuffer(id2, strlen(kTestPageContents2));
306 NotifyDataReceived(id2, kTestPageContents2);
307 ConsumeDataReceived_ACK(id2);
308 NotifySetDataBuffer(id1, strlen(kTestPageContents));
309 NotifyDataReceived(id1, kTestPageContents);
310 ConsumeDataReceived_ACK(id1);
311 EXPECT_EQ(0u, queued_messages());
312
313 NotifyRequestComplete(id1, strlen(kTestPageContents));
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]314 EXPECT_EQ(kTestPageContents, peer_context1.data);
315 EXPECT_TRUE(peer_context1.complete);
316 EXPECT_FALSE(peer_context2.complete);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]317
318 NotifyRequestComplete(id2, strlen(kTestPageContents2));
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]319 EXPECT_EQ(kTestPageContents2, peer_context2.data);
320 EXPECT_TRUE(peer_context2.complete);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]321
322 EXPECT_EQ(0u, queued_messages());
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]323}
324
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]325// Tests that the cancel method prevents other messages from being received.
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]326TEST_F(ResourceDispatcherTest, Cancel) {
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]327 std::unique_ptr<ResourceRequest> request(CreateResourceRequest(false));
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]328 TestRequestPeer::Context peer_context;
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]329 int request_id = StartAsync(std::move(request), NULL, &peer_context);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]330
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]331 int id = ConsumeRequestResource();
332 EXPECT_EQ(0u, queued_messages());
333
334 // Cancel the request.
jam4a1511ef2015-02-19 20:29:17[diff] [blame]335 dispatcher()->Cancel(request_id);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]336 ConsumeCancelRequest(id);
337
338 // Any future messages related to the request should be ignored.
339 NotifyReceivedResponse(id);
340 NotifySetDataBuffer(id, strlen(kTestPageContents));
341 NotifyDataReceived(id, kTestPageContents);
342 NotifyRequestComplete(id, strlen(kTestPageContents));
343
344 EXPECT_EQ(0u, queued_messages());
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]345 EXPECT_EQ("", peer_context.data);
346 EXPECT_FALSE(peer_context.received_response);
347 EXPECT_FALSE(peer_context.complete);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]348}
349
350// Tests that calling cancel during a callback works as expected.
351TEST_F(ResourceDispatcherTest, CancelDuringCallback) {
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]352 std::unique_ptr<ResourceRequest> request(CreateResourceRequest(false));
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]353 TestRequestPeer::Context peer_context;
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]354 StartAsync(std::move(request), NULL, &peer_context);
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]355 peer_context.cancel_on_receive_response = true;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]356
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]357 int id = ConsumeRequestResource();
358 EXPECT_EQ(0u, queued_messages());
359
360 NotifyReceivedResponse(id);
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]361 EXPECT_TRUE(peer_context.received_response);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]362 // Request should have been cancelled.
363 ConsumeCancelRequest(id);
364
365 // Any future messages related to the request should be ignored.
366 NotifySetDataBuffer(id, strlen(kTestPageContents));
367 NotifyDataReceived(id, kTestPageContents);
368 NotifyRequestComplete(id, strlen(kTestPageContents));
369
370 EXPECT_EQ(0u, queued_messages());
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]371 EXPECT_EQ("", peer_context.data);
372 EXPECT_FALSE(peer_context.complete);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]373}
374
kinuko5e4122a22016-02-09 02:38:24[diff] [blame]375class TestResourceDispatcherDelegate : public ResourceDispatcherDelegate {
376 public:
377 TestResourceDispatcherDelegate() {}
378 ~TestResourceDispatcherDelegate() override {}
379
dchengc864f522016-04-08 23:55:27[diff] [blame]380 std::unique_ptr<RequestPeer> OnRequestComplete(
381 std::unique_ptr<RequestPeer> current_peer,
kinuko5e4122a22016-02-09 02:38:24[diff] [blame]382 ResourceType resource_type,
383 int error_code) override {
384 return current_peer;
385 }
386
dchengc864f522016-04-08 23:55:27[diff] [blame]387 std::unique_ptr<RequestPeer> OnReceivedResponse(
388 std::unique_ptr<RequestPeer> current_peer,
kinuko5e4122a22016-02-09 02:38:24[diff] [blame]389 const std::string& mime_type,
390 const GURL& url) override {
riceabb403262016-08-25 05:26:51[diff] [blame]391 return base::MakeUnique<WrapperPeer>(std::move(current_peer));
kinuko5e4122a22016-02-09 02:38:24[diff] [blame]392 }
393
394 class WrapperPeer : public RequestPeer {
395 public:
dchengc864f522016-04-08 23:55:27[diff] [blame]396 explicit WrapperPeer(std::unique_ptr<RequestPeer> original_peer)
kinuko5e4122a22016-02-09 02:38:24[diff] [blame]397 : original_peer_(std::move(original_peer)) {}
398
399 void OnUploadProgress(uint64_t position, uint64_t size) override {}
400
401 bool OnReceivedRedirect(const net::RedirectInfo& redirect_info,
402 const ResourceResponseInfo& info) override {
403 return false;
404 }
405
406 void OnReceivedResponse(const ResourceResponseInfo& info) override {
407 response_info_ = info;
408 }
409
410 void OnDownloadedData(int len, int encoded_data_length) override {}
411
dchengc864f522016-04-08 23:55:27[diff] [blame]412 void OnReceivedData(std::unique_ptr<ReceivedData> data) override {
kinuko5e4122a22016-02-09 02:38:24[diff] [blame]413 data_.append(data->payload(), data->length());
414 }
yhirano48f3e042016-12-09 02:19:17[diff] [blame]415 void OnTransferSizeUpdated(int transfer_size_diff) override {}
kinuko5e4122a22016-02-09 02:38:24[diff] [blame]416
417 void OnCompletedRequest(int error_code,
418 bool was_ignored_by_handler,
419 bool stale_copy_in_cache,
kinuko5e4122a22016-02-09 02:38:24[diff] [blame]420 const base::TimeTicks& completion_time,
yhiranob82cdb02402016-11-28 14:17:42[diff] [blame]421 int64_t total_transfer_size,
horoe8442e62017-04-27 19:10:48[diff] [blame]422 int64_t encoded_body_size,
423 int64_t decoded_body_size) override {
kinuko5e4122a22016-02-09 02:38:24[diff] [blame]424 original_peer_->OnReceivedResponse(response_info_);
425 if (!data_.empty()) {
yhirano48f3e042016-12-09 02:19:17[diff] [blame]426 original_peer_->OnReceivedData(
427 base::MakeUnique<FixedReceivedData>(data_.data(), data_.size()));
kinuko5e4122a22016-02-09 02:38:24[diff] [blame]428 }
horoe8442e62017-04-27 19:10:48[diff] [blame]429 original_peer_->OnCompletedRequest(error_code, was_ignored_by_handler,
430 stale_copy_in_cache, completion_time,
431 total_transfer_size, encoded_body_size,
432 decoded_body_size);
kinuko5e4122a22016-02-09 02:38:24[diff] [blame]433 }
434
435 private:
dchengc864f522016-04-08 23:55:27[diff] [blame]436 std::unique_ptr<RequestPeer> original_peer_;
kinuko5e4122a22016-02-09 02:38:24[diff] [blame]437 ResourceResponseInfo response_info_;
438 std::string data_;
439
440 DISALLOW_COPY_AND_ASSIGN(WrapperPeer);
441 };
442
443 private:
444 DISALLOW_COPY_AND_ASSIGN(TestResourceDispatcherDelegate);
445};
446
447TEST_F(ResourceDispatcherTest, DelegateTest) {
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]448 std::unique_ptr<ResourceRequest> request(CreateResourceRequest(false));
kinuko5e4122a22016-02-09 02:38:24[diff] [blame]449 TestRequestPeer::Context peer_context;
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]450 StartAsync(std::move(request), nullptr, &peer_context);
kinuko5e4122a22016-02-09 02:38:24[diff] [blame]451
452 // Set the delegate that inserts a new peer in OnReceivedResponse.
453 TestResourceDispatcherDelegate delegate;
454 dispatcher()->set_delegate(&delegate);
455
456 // Run a simple round-trip.
457 const size_t kFirstReceiveSize = 2;
458 ASSERT_LT(kFirstReceiveSize, strlen(kTestPageContents));
459
460 int id = ConsumeRequestResource();
461 EXPECT_EQ(0u, queued_messages());
462
463 // The wrapper eats all messages until RequestComplete message is sent.
464 NotifyReceivedResponse(id);
465 NotifySetDataBuffer(id, strlen(kTestPageContents));
466 NotifyDataReceived(id, std::string(kTestPageContents, kFirstReceiveSize));
467 ConsumeDataReceived_ACK(id);
468 NotifyDataReceived(id, kTestPageContents + kFirstReceiveSize);
469 ConsumeDataReceived_ACK(id);
470
471 EXPECT_FALSE(peer_context.received_response);
472 EXPECT_EQ(0u, queued_messages());
473
474 // This lets the wrapper peer pass all the messages to the original
475 // peer at once.
476 NotifyRequestComplete(id, strlen(kTestPageContents));
477
478 EXPECT_TRUE(peer_context.received_response);
479 EXPECT_EQ(kTestPageContents, peer_context.data);
480 EXPECT_TRUE(peer_context.complete);
481 EXPECT_EQ(0u, queued_messages());
482}
483
484TEST_F(ResourceDispatcherTest, CancelDuringCallbackWithWrapperPeer) {
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]485 std::unique_ptr<ResourceRequest> request(CreateResourceRequest(false));
kinuko5e4122a22016-02-09 02:38:24[diff] [blame]486 TestRequestPeer::Context peer_context;
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]487 StartAsync(std::move(request), nullptr, &peer_context);
kinuko5e4122a22016-02-09 02:38:24[diff] [blame]488 peer_context.cancel_on_receive_response = true;
489
490 // Set the delegate that inserts a new peer in OnReceivedResponse.
491 TestResourceDispatcherDelegate delegate;
492 dispatcher()->set_delegate(&delegate);
493
494 int id = ConsumeRequestResource();
495 EXPECT_EQ(0u, queued_messages());
496
497 // The wrapper eats all messages until RequestComplete message is sent.
498 NotifyReceivedResponse(id);
499 NotifySetDataBuffer(id, strlen(kTestPageContents));
500 NotifyDataReceived(id, kTestPageContents);
501 ConsumeDataReceived_ACK(id);
502
503 EXPECT_FALSE(peer_context.received_response);
504 EXPECT_EQ(0u, queued_messages());
505
506 // This lets the wrapper peer pass all the messages to the original
507 // peer at once, but the original peer cancels right after it receives
508 // the response. (This will remove pending request info from
509 // ResourceDispatcher while the wrapper peer is still running
510 // OnCompletedRequest, but it should not lead to crashes.)
511 NotifyRequestComplete(id, strlen(kTestPageContents));
512
513 EXPECT_TRUE(peer_context.received_response);
pmeenan8b3bca12016-09-09 12:25:54[diff] [blame]514 // Request should have been cancelled with no additional messages.
515 EXPECT_EQ(0u, queued_messages());
kinuko5e4122a22016-02-09 02:38:24[diff] [blame]516 EXPECT_TRUE(peer_context.cancelled);
517
518 // Any future messages related to the request should be ignored.
519 NotifyDataReceived(id, kTestPageContents);
520 NotifyRequestComplete(id, strlen(kTestPageContents));
521
522 EXPECT_EQ(0u, queued_messages());
523 EXPECT_EQ("", peer_context.data);
524 EXPECT_FALSE(peer_context.complete);
525}
526
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]527// Checks that redirects work as expected.
528TEST_F(ResourceDispatcherTest, Redirect) {
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]529 std::unique_ptr<ResourceRequest> request(CreateResourceRequest(false));
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]530 TestRequestPeer::Context peer_context;
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]531 StartAsync(std::move(request), NULL, &peer_context);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]532
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]533 int id = ConsumeRequestResource();
534
535 NotifyReceivedRedirect(id);
536 ConsumeFollowRedirect(id);
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]537 EXPECT_EQ(1, peer_context.seen_redirects);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]538
539 NotifyReceivedRedirect(id);
540 ConsumeFollowRedirect(id);
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]541 EXPECT_EQ(2, peer_context.seen_redirects);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]542
543 NotifyReceivedResponse(id);
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]544 EXPECT_TRUE(peer_context.received_response);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]545
546 NotifySetDataBuffer(id, strlen(kTestPageContents));
547 NotifyDataReceived(id, kTestPageContents);
548 ConsumeDataReceived_ACK(id);
549
550 NotifyRequestComplete(id, strlen(kTestPageContents));
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]551 EXPECT_EQ(kTestPageContents, peer_context.data);
552 EXPECT_TRUE(peer_context.complete);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]553 EXPECT_EQ(0u, queued_messages());
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]554 EXPECT_EQ(2, peer_context.seen_redirects);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]555}
556
557// Tests that that cancelling during a redirect method prevents other messages
558// from being received.
559TEST_F(ResourceDispatcherTest, CancelDuringRedirect) {
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]560 std::unique_ptr<ResourceRequest> request(CreateResourceRequest(false));
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]561 TestRequestPeer::Context peer_context;
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]562 StartAsync(std::move(request), NULL, &peer_context);
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]563 peer_context.follow_redirects = false;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]564
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]565 int id = ConsumeRequestResource();
566 EXPECT_EQ(0u, queued_messages());
567
568 // Redirect the request, which triggers a cancellation.
569 NotifyReceivedRedirect(id);
570 ConsumeCancelRequest(id);
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]571 EXPECT_EQ(1, peer_context.seen_redirects);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]572 EXPECT_EQ(0u, queued_messages());
573
574 // Any future messages related to the request should be ignored. In practice,
575 // only the NotifyRequestComplete should be received after this point.
576 NotifyReceivedRedirect(id);
577 NotifyReceivedResponse(id);
578 NotifySetDataBuffer(id, strlen(kTestPageContents));
579 NotifyDataReceived(id, kTestPageContents);
580 NotifyRequestComplete(id, strlen(kTestPageContents));
581
582 EXPECT_EQ(0u, queued_messages());
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]583 EXPECT_EQ("", peer_context.data);
584 EXPECT_FALSE(peer_context.complete);
585 EXPECT_EQ(1, peer_context.seen_redirects);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]586}
587
588// Checks that deferring a request delays messages until it's resumed.
589TEST_F(ResourceDispatcherTest, Defer) {
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]590 std::unique_ptr<ResourceRequest> request(CreateResourceRequest(false));
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]591 TestRequestPeer::Context peer_context;
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]592 int request_id = StartAsync(std::move(request), NULL, &peer_context);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]593
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]594 int id = ConsumeRequestResource();
595 EXPECT_EQ(0u, queued_messages());
596
jam4a1511ef2015-02-19 20:29:17[diff] [blame]597 dispatcher()->SetDefersLoading(request_id, true);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]598 NotifyReceivedResponse(id);
599 NotifySetDataBuffer(id, strlen(kTestPageContents));
600 NotifyDataReceived(id, kTestPageContents);
601 NotifyRequestComplete(id, strlen(kTestPageContents));
602
603 // None of the messages should have been processed yet, so no queued messages
604 // to the browser process, and no data received by the peer.
605 EXPECT_EQ(0u, queued_messages());
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]606 EXPECT_EQ("", peer_context.data);
607 EXPECT_FALSE(peer_context.complete);
608 EXPECT_EQ(0, peer_context.seen_redirects);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]609
610 // Resuming the request should asynchronously unleash the deferred messages.
jam4a1511ef2015-02-19 20:29:17[diff] [blame]611 dispatcher()->SetDefersLoading(request_id, false);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]612 base::RunLoop().RunUntilIdle();
613
614 ConsumeDataReceived_ACK(id);
615 EXPECT_EQ(0u, queued_messages());
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]616 EXPECT_TRUE(peer_context.received_response);
617 EXPECT_EQ(kTestPageContents, peer_context.data);
618 EXPECT_TRUE(peer_context.complete);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]619}
620
621// Checks that deferring a request during a redirect delays messages until it's
622// resumed.
623TEST_F(ResourceDispatcherTest, DeferOnRedirect) {
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]624 std::unique_ptr<ResourceRequest> request(CreateResourceRequest(false));
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]625 TestRequestPeer::Context peer_context;
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]626 int request_id = StartAsync(std::move(request), NULL, &peer_context);
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]627 peer_context.defer_on_redirect = true;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]628
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]629 int id = ConsumeRequestResource();
630 EXPECT_EQ(0u, queued_messages());
631
632 // The request should be deferred during the redirect, including the message
633 // to follow the redirect.
634 NotifyReceivedRedirect(id);
635 NotifyReceivedResponse(id);
636 NotifySetDataBuffer(id, strlen(kTestPageContents));
637 NotifyDataReceived(id, kTestPageContents);
638 NotifyRequestComplete(id, strlen(kTestPageContents));
639
640 // None of the messages should have been processed yet, so no queued messages
641 // to the browser process, and no data received by the peer.
642 EXPECT_EQ(0u, queued_messages());
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]643 EXPECT_EQ("", peer_context.data);
644 EXPECT_FALSE(peer_context.complete);
645 EXPECT_EQ(1, peer_context.seen_redirects);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]646
647 // Resuming the request should asynchronously unleash the deferred messages.
jam4a1511ef2015-02-19 20:29:17[diff] [blame]648 dispatcher()->SetDefersLoading(request_id, false);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]649 base::RunLoop().RunUntilIdle();
650
651 ConsumeFollowRedirect(id);
652 ConsumeDataReceived_ACK(id);
653
654 EXPECT_EQ(0u, queued_messages());
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]655 EXPECT_TRUE(peer_context.received_response);
656 EXPECT_EQ(kTestPageContents, peer_context.data);
657 EXPECT_TRUE(peer_context.complete);
658 EXPECT_EQ(1, peer_context.seen_redirects);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]659}
660
661// Checks that a deferred request that's cancelled doesn't receive any messages.
662TEST_F(ResourceDispatcherTest, CancelDeferredRequest) {
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]663 std::unique_ptr<ResourceRequest> request(CreateResourceRequest(false));
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]664 TestRequestPeer::Context peer_context;
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]665 int request_id = StartAsync(std::move(request), NULL, &peer_context);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]666
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]667 int id = ConsumeRequestResource();
668 EXPECT_EQ(0u, queued_messages());
669
jam4a1511ef2015-02-19 20:29:17[diff] [blame]670 dispatcher()->SetDefersLoading(request_id, true);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]671 NotifyReceivedRedirect(id);
jam4a1511ef2015-02-19 20:29:17[diff] [blame]672 dispatcher()->Cancel(request_id);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]673 ConsumeCancelRequest(id);
674
675 NotifyRequestComplete(id, 0);
676 base::RunLoop().RunUntilIdle();
677
678 // None of the messages should have been processed.
679 EXPECT_EQ(0u, queued_messages());
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]680 EXPECT_EQ("", peer_context.data);
681 EXPECT_FALSE(peer_context.complete);
682 EXPECT_EQ(0, peer_context.seen_redirects);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]683}
684
jb864cf452016-10-25 08:34:22[diff] [blame]685// Checks cancelling a request while flushing deferred requests from
686// the FlushDeferredMessages() task.
687TEST_F(ResourceDispatcherTest, CancelWhileFlushingDeferredRequests) {
688 std::unique_ptr<ResourceRequest> request(CreateResourceRequest(false));
689 TestRequestPeer::Context peer_context;
690 int request_id = StartAsync(std::move(request), NULL, &peer_context);
691
692 // Cancel the request when the data message is handled.
693 peer_context.cancel_on_receive_data = true;
694
695 int id = ConsumeRequestResource();
696 EXPECT_EQ(0u, queued_messages());
697
698 dispatcher()->SetDefersLoading(request_id, true);
699 NotifyReceivedResponse(id);
700 NotifySetDataBuffer(id, strlen(kTestPageContents));
701 NotifyDataReceived(id, kTestPageContents);
702
703 // None of the messages should have been processed yet.
704 EXPECT_EQ("", peer_context.data);
705 EXPECT_FALSE(peer_context.complete);
706 EXPECT_EQ(0u, queued_messages());
707
708 dispatcher()->SetDefersLoading(request_id, false);
709
710 // Make sure that the FlushDeferredMessages() task posted from
711 // SetDefersLoading() is run. It should dispatch all the deferred
712 // messages.
713 base::RunLoop().RunUntilIdle();
714
715 // When the deferred DataReceived is dispatched, the handler will
716 // cancel the request, but the ACK is sent after the handler
717 // returns, so the cancel request ends up before the ACK in the
718 // message queue.
719 ConsumeCancelRequest(id);
720 ConsumeDataReceived_ACK(id);
721
722 // The data was consumed before the handler canceled
723 // the request, so the data should have been received.
724 EXPECT_EQ(kTestPageContents, peer_context.data);
725 EXPECT_FALSE(peer_context.complete);
726 EXPECT_EQ(0u, queued_messages());
727}
728
729// Checks cancelling a request while flushing deferred requests from
730// OnMessageReceived().
731TEST_F(ResourceDispatcherTest,
732 CancelWhileFlushingDeferredRequestsFromOnMessageReceived) {
733 std::unique_ptr<ResourceRequest> request(CreateResourceRequest(false));
734 TestRequestPeer::Context peer_context;
735 int request_id = StartAsync(std::move(request), NULL, &peer_context);
736
737 // Cancel the request when the data message is handled.
738 peer_context.cancel_on_receive_data = true;
739
740 int id = ConsumeRequestResource();
741 EXPECT_EQ(0u, queued_messages());
742
743 dispatcher()->SetDefersLoading(request_id, true);
744 NotifyReceivedResponse(id);
745 NotifySetDataBuffer(id, strlen(kTestPageContents));
746 NotifyDataReceived(id, kTestPageContents);
747
748 // None of the messages should have been processed yet.
749 EXPECT_EQ("", peer_context.data);
750 EXPECT_FALSE(peer_context.complete);
751 EXPECT_EQ(0u, queued_messages());
752
753 dispatcher()->SetDefersLoading(request_id, false);
754
755 // SetDefersLoading() posts a task to run FlushDeferredMessages() to dispatch
756 // the deferred messages. Since the message loop hasn't been run yet the
757 // task hasn't been run either and no IPC-messages should have been
758 // dispatched.
759 EXPECT_EQ("", peer_context.data);
760 EXPECT_FALSE(peer_context.complete);
761 EXPECT_EQ(0u, queued_messages());
762
763 // Calling NotifyRequestComplete() here, before the task from
764 // SetDefersLoading() has been run, triggers the flush in
765 // OnMessageReceived().
766 NotifyRequestComplete(id, strlen(kTestPageContents));
767
768 // When the deferred DataReceived is dispatched, the handler will
769 // cancel the request, but the ACK is sent after the handler
770 // returns, so the cancel request ends up before the ACK in the
771 // message queue.
772 ConsumeCancelRequest(id);
773 ConsumeDataReceived_ACK(id);
774
775 // The data was consumed before the handler canceled
776 // the request, so the data should have been received.
777 EXPECT_EQ(kTestPageContents, peer_context.data);
778 EXPECT_FALSE(peer_context.complete);
779 EXPECT_EQ(0u, queued_messages());
780
781 // Make sure that the FlushDeferredMessages() task posted from
782 // SetDefersLoading() is run. The messages should already have been
783 // flushed above, so it should be a NOOP.
784 base::RunLoop().RunUntilIdle();
785
786 // Check that the task didn't change anything.
787 EXPECT_EQ(kTestPageContents, peer_context.data);
788 EXPECT_FALSE(peer_context.complete);
789 EXPECT_EQ(0u, queued_messages());
790}
791
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]792TEST_F(ResourceDispatcherTest, DownloadToFile) {
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]793 std::unique_ptr<ResourceRequest> request(CreateResourceRequest(true));
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]794 TestRequestPeer::Context peer_context;
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]795 int request_id = StartAsync(std::move(request), NULL, &peer_context);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]796 const int kDownloadedIncrement = 100;
797 const int kEncodedIncrement = 50;
798
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]799 int id = ConsumeRequestResource();
800 EXPECT_EQ(0u, queued_messages());
801
802 NotifyReceivedResponse(id);
803 EXPECT_EQ(0u, queued_messages());
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]804 EXPECT_TRUE(peer_context.received_response);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]805
806 int expected_total_downloaded_length = 0;
ricead91ea732016-07-20 12:53:28[diff] [blame]807 int expected_total_encoded_data_length = 0;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]808 for (int i = 0; i < 10; ++i) {
809 NotifyDataDownloaded(id, kDownloadedIncrement, kEncodedIncrement);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]810 expected_total_downloaded_length += kDownloadedIncrement;
ricead91ea732016-07-20 12:53:28[diff] [blame]811 expected_total_encoded_data_length += kEncodedIncrement;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]812 EXPECT_EQ(expected_total_downloaded_length,
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]813 peer_context.total_downloaded_data_length);
ricead91ea732016-07-20 12:53:28[diff] [blame]814 EXPECT_EQ(expected_total_encoded_data_length,
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]815 peer_context.total_encoded_data_length);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]816 }
817
818 NotifyRequestComplete(id, strlen(kTestPageContents));
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]819 EXPECT_EQ("", peer_context.data);
820 EXPECT_TRUE(peer_context.complete);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]821 EXPECT_EQ(0u, queued_messages());
822
jam4a1511ef2015-02-19 20:29:17[diff] [blame]823 dispatcher()->RemovePendingRequest(request_id);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]824 ConsumeReleaseDownloadedFile(id);
825 EXPECT_EQ(0u, queued_messages());
826 EXPECT_EQ(expected_total_downloaded_length,
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]827 peer_context.total_downloaded_data_length);
ricead91ea732016-07-20 12:53:28[diff] [blame]828 EXPECT_EQ(expected_total_encoded_data_length,
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]829 peer_context.total_encoded_data_length);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]830}
831
832// Make sure that when a download to file is cancelled, the file is destroyed.
833TEST_F(ResourceDispatcherTest, CancelDownloadToFile) {
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]834 std::unique_ptr<ResourceRequest> request(CreateResourceRequest(true));
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]835 TestRequestPeer::Context peer_context;
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]836 int request_id = StartAsync(std::move(request), NULL, &peer_context);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]837
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]838 int id = ConsumeRequestResource();
839 EXPECT_EQ(0u, queued_messages());
840
841 NotifyReceivedResponse(id);
842 EXPECT_EQ(0u, queued_messages());
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]843 EXPECT_TRUE(peer_context.received_response);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]844
845 // Cancelling the request deletes the file.
jam4a1511ef2015-02-19 20:29:17[diff] [blame]846 dispatcher()->Cancel(request_id);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]847 ConsumeCancelRequest(id);
848 ConsumeReleaseDownloadedFile(id);
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]849}
850
851TEST_F(ResourceDispatcherTest, Cookies) {
852 // FIXME
853}
854
855TEST_F(ResourceDispatcherTest, SerializedPostData) {
856 // FIXME
857}
[email protected]2602087e2009-08-24 23:12:16[diff] [blame]858
kinuko85732232016-01-06 04:20:42[diff] [blame]859class TimeConversionTest : public ResourceDispatcherTest {
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]860 public:
dchenge933b3e2014-10-21 11:44:09[diff] [blame]861 bool Send(IPC::Message* msg) override {
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]862 delete msg;
863 return true;
864 }
865
866 void PerformTest(const ResourceResponseHead& response_head) {
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]867 std::unique_ptr<ResourceRequest> request(CreateResourceRequest(false));
kinukoccbf2c9572016-02-03 22:54:37[diff] [blame]868 TestRequestPeer::Context peer_context;
tyoshino3191d5fe42016-09-21 07:28:05[diff] [blame]869 StartAsync(std::move(request), NULL, &peer_context);
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]870
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]871 dispatcher()->OnMessageReceived(
[email protected]f4653192013-09-06 19:24:05[diff] [blame]872 ResourceMsg_ReceivedResponse(0, response_head));
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]873 }
874
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]875 const ResourceResponseInfo& response_info() const { return response_info_; }
876
877 private:
878 ResourceResponseInfo response_info_;
879};
880
881// TODO(simonjam): Enable this when 10829031 lands.
882TEST_F(TimeConversionTest, DISABLED_ProperlyInitialized) {
883 ResourceResponseHead response_head;
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]884 response_head.request_start = base::TimeTicks::FromInternalValue(5);
885 response_head.response_start = base::TimeTicks::FromInternalValue(15);
[email protected]ec298802013-03-27 16:45:07[diff] [blame]886 response_head.load_timing.request_start_time = base::Time::Now();
887 response_head.load_timing.request_start =
888 base::TimeTicks::FromInternalValue(10);
889 response_head.load_timing.connect_timing.connect_start =
890 base::TimeTicks::FromInternalValue(13);
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]891
892 PerformTest(response_head);
893
[email protected]ec298802013-03-27 16:45:07[diff] [blame]894 EXPECT_LT(base::TimeTicks(), response_info().load_timing.request_start);
895 EXPECT_EQ(base::TimeTicks(),
896 response_info().load_timing.connect_timing.dns_start);
897 EXPECT_LE(response_head.load_timing.request_start,
898 response_info().load_timing.connect_timing.connect_start);
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]899}
900
901TEST_F(TimeConversionTest, PartiallyInitialized) {
902 ResourceResponseHead response_head;
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]903 response_head.request_start = base::TimeTicks::FromInternalValue(5);
904 response_head.response_start = base::TimeTicks::FromInternalValue(15);
905
906 PerformTest(response_head);
907
[email protected]ec298802013-03-27 16:45:07[diff] [blame]908 EXPECT_EQ(base::TimeTicks(), response_info().load_timing.request_start);
909 EXPECT_EQ(base::TimeTicks(),
910 response_info().load_timing.connect_timing.dns_start);
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]911}
912
913TEST_F(TimeConversionTest, NotInitialized) {
914 ResourceResponseHead response_head;
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]915
916 PerformTest(response_head);
917
[email protected]ec298802013-03-27 16:45:07[diff] [blame]918 EXPECT_EQ(base::TimeTicks(), response_info().load_timing.request_start);
919 EXPECT_EQ(base::TimeTicks(),
920 response_info().load_timing.connect_timing.dns_start);
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]921}
922
[email protected]be7b41e82012-07-04 09:46:51[diff] [blame]923} // namespace content