Google Git
Sign in
chromium / chromium / src.git / 7cf10ca7017bed4b6fac3596b9b9080bf208c7d4 / . / content / child / resource_dispatcher_unittest.cc
blob: 0f26c8219ae095a7206e4bdc3a6ea7777e7652da [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
5#include <string>
6#include <vector>
7
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]8#include "base/macros.h"
[email protected]3b63f8f42011-03-28 01:54:15[diff] [blame]9#include "base/memory/scoped_ptr.h"
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]10#include "base/memory/shared_memory.h"
[email protected]e55f5642013-07-18 00:22:54[diff] [blame]11#include "base/message_loop/message_loop.h"
[email protected]54724e22013-07-25 13:02:15[diff] [blame]12#include "base/process/process_handle.h"
[email protected]2a1a06d2014-06-04 12:24:36[diff] [blame]13#include "base/run_loop.h"
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]14#include "base/stl_util.h"
[email protected]541b7b02013-06-07 00:59:34[diff] [blame]15#include "content/child/request_extra_data.h"
[email protected]abfd92e2014-03-24 02:34:46[diff] [blame]16#include "content/child/request_info.h"
[email protected]10208ea2013-06-06 20:08:03[diff] [blame]17#include "content/child/resource_dispatcher.h"
[email protected]98d6d4562014-06-25 20:57:55[diff] [blame]18#include "content/common/appcache_interfaces.h"
[email protected]94dc971d2011-03-05 19:08:32[diff] [blame]19#include "content/common/resource_messages.h"
[email protected]fa07f6572014-03-06 13:10:10[diff] [blame]20#include "content/common/service_worker/service_worker_types.h"
[email protected]ddf55bb2014-04-03 08:24:47[diff] [blame]21#include "content/public/child/request_peer.h"
[email protected]2336ffe2011-11-24 01:23:34[diff] [blame]22#include "content/public/common/resource_response.h"
[email protected]2756a8e2012-09-07 18:24:29[diff] [blame]23#include "net/base/net_errors.h"
[email protected]7a4de7a62010-08-17 18:38:24[diff] [blame]24#include "net/http/http_response_headers.h"
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]25#include "testing/gtest/include/gtest/gtest.h"
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]26
[email protected]be7b41e82012-07-04 09:46:51[diff] [blame]27namespace content {
28
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]29static const char kTestPageUrl[] = "http://www.google.com/";
30static const char kTestPageHeaders[] =
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]31 "HTTP/1.1 200 OK\nContent-Type:text/html\n\n";
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]32static const char kTestPageMimeType[] = "text/html";
33static const char kTestPageCharset[] = "";
34static const char kTestPageContents[] =
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]35 "<html><head><title>Google</title></head><body><h1>Google</h1></body></html>";
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]36static const char kTestRedirectHeaders[] =
37 "HTTP/1.1 302 Found\nLocation:http://www.google.com/\n\n";
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]38
39// Listens for request response data and stores it so that it can be compared
40// to the reference data.
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]41class TestRequestPeer : public RequestPeer {
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]42 public:
jam4a1511ef2015-02-19 20:29:17[diff] [blame]43 TestRequestPeer(ResourceDispatcher* dispatcher)
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]44 : follow_redirects_(true),
45 defer_on_redirect_(false),
46 seen_redirects_(0),
47 cancel_on_receive_response_(false),
48 received_response_(false),
49 total_encoded_data_length_(0),
50 total_downloaded_data_length_(0),
51 complete_(false),
jam4a1511ef2015-02-19 20:29:17[diff] [blame]52 dispatcher_(dispatcher),
53 request_id_(0) {
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]54 }
55
jam4a1511ef2015-02-19 20:29:17[diff] [blame]56 void set_request_id(int request_id) { request_id_ = request_id; }
57
dchenge933b3e2014-10-21 11:44:09[diff] [blame]58 void OnUploadProgress(uint64 position, uint64 size) override {}
[email protected]bb551622010-07-22 20:52:49[diff] [blame]59
dchenge933b3e2014-10-21 11:44:09[diff] [blame]60 bool OnReceivedRedirect(const net::RedirectInfo& redirect_info,
61 const ResourceResponseInfo& info) override {
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]62 ++seen_redirects_;
63 if (defer_on_redirect_)
jam4a1511ef2015-02-19 20:29:17[diff] [blame]64 dispatcher_->SetDefersLoading(request_id_, true);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]65 return follow_redirects_;
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]66 }
67
dchenge933b3e2014-10-21 11:44:09[diff] [blame]68 void OnReceivedResponse(const ResourceResponseInfo& info) override {
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]69 EXPECT_FALSE(received_response_);
70 received_response_ = true;
71 if (cancel_on_receive_response_)
jam4a1511ef2015-02-19 20:29:17[diff] [blame]72 dispatcher_->Cancel(request_id_);
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]73 }
74
dchenge933b3e2014-10-21 11:44:09[diff] [blame]75 void OnDownloadedData(int len, int encoded_data_length) override {
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]76 total_downloaded_data_length_ += len;
77 total_encoded_data_length_ += encoded_data_length;
[email protected]bb551622010-07-22 20:52:49[diff] [blame]78 }
79
yhiranof0a364e2015-06-03 04:49:50[diff] [blame]80 void OnReceivedData(scoped_ptr<ReceivedData> data) override {
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]81 EXPECT_TRUE(received_response_);
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]82 EXPECT_FALSE(complete_);
yhiranof0a364e2015-06-03 04:49:50[diff] [blame]83 data_.append(data->payload(), data->length());
84 total_encoded_data_length_ += data->encoded_length();
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]85 }
86
dchenge933b3e2014-10-21 11:44:09[diff] [blame]87 void OnCompletedRequest(int error_code,
88 bool was_ignored_by_handler,
89 bool stale_copy_in_cache,
90 const std::string& security_info,
91 const base::TimeTicks& completion_time,
92 int64 total_transfer_size) override {
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]93 EXPECT_TRUE(received_response_);
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]94 EXPECT_FALSE(complete_);
95 complete_ = true;
96 }
97
yhirano33187ed2015-07-08 05:22:11[diff] [blame]98 void OnReceivedCompletedResponse(const ResourceResponseInfo& info,
99 scoped_ptr<ReceivedData> data,
100 int error_code,
101 bool was_ignored_by_handler,
102 bool stale_copy_in_cache,
103 const std::string& security_info,
104 const base::TimeTicks& completion_time,
105 int64 total_transfer_size) override {
106 bool cancel_on_receive_response = cancel_on_receive_response_;
107 OnReceivedResponse(info);
108 if (cancel_on_receive_response)
109 return;
110 if (data)
111 OnReceivedData(data.Pass());
112 OnCompletedRequest(error_code, was_ignored_by_handler, stale_copy_in_cache,
113 security_info, completion_time, total_transfer_size);
114 }
115
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]116 void set_follow_redirects(bool follow_redirects) {
117 follow_redirects_ = follow_redirects;
[email protected]8bd0de72011-04-08 18:52:10[diff] [blame]118 }
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]119
120 void set_defer_on_redirect(bool defer_on_redirect) {
121 defer_on_redirect_ = defer_on_redirect;
122 }
123
124 void set_cancel_on_receive_response(bool cancel_on_receive_response) {
125 cancel_on_receive_response_ = cancel_on_receive_response;
126 }
127
128 int seen_redirects() const { return seen_redirects_; }
129
130 bool received_response() const { return received_response_; }
131
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]132 const std::string& data() const {
133 return data_;
134 }
[email protected]dfd682172011-04-13 19:57:25[diff] [blame]135 int total_encoded_data_length() const {
136 return total_encoded_data_length_;
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]137 }
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]138 int total_downloaded_data_length() const {
139 return total_downloaded_data_length_;
140 }
141
142 bool complete() const { return complete_; }
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]143
144 private:
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]145 // True if should follow redirects, false if should cancel them.
146 bool follow_redirects_;
147 // True if the request should be deferred on redirects.
148 bool defer_on_redirect_;
149 // Number of total redirects seen.
150 int seen_redirects_;
151
152 bool cancel_on_receive_response_;
153 bool received_response_;
154
155 // Data received. If downloading to file, remains empty.
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]156 std::string data_;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]157 // Total encoded data length, regardless of whether downloading to a file or
158 // not.
[email protected]dfd682172011-04-13 19:57:25[diff] [blame]159 int total_encoded_data_length_;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]160 // Total length when downloading to a file.
161 int total_downloaded_data_length_;
162
163 bool complete_;
164
jam4a1511ef2015-02-19 20:29:17[diff] [blame]165 ResourceDispatcher* dispatcher_;
166 int request_id_;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]167
168 DISALLOW_COPY_AND_ASSIGN(TestRequestPeer);
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]169};
170
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]171// Sets up the message sender override for the unit test.
[email protected]d84effeb2012-06-25 17:03:10[diff] [blame]172class ResourceDispatcherTest : public testing::Test, public IPC::Sender {
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]173 public:
alexclarke0bc36e8d32014-12-17 17:29:20[diff] [blame]174 ResourceDispatcherTest() : dispatcher_(this, message_loop_.task_runner()) {}
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]175
dchengf5762152014-10-29 02:12:06[diff] [blame]176 ~ResourceDispatcherTest() override {
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]177 STLDeleteContainerPairSecondPointers(shared_memory_map_.begin(),
178 shared_memory_map_.end());
179 }
180
[email protected]d84effeb2012-06-25 17:03:10[diff] [blame]181 // Emulates IPC send operations (IPC::Sender) by adding
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]182 // pending messages to the queue.
dchenge933b3e2014-10-21 11:44:09[diff] [blame]183 bool Send(IPC::Message* msg) override {
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]184 message_queue_.push_back(IPC::Message(*msg));
185 delete msg;
186 return true;
187 }
188
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]189 size_t queued_messages() const { return message_queue_.size(); }
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]190
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]191 // Returns the ID of the consumed request. Can't make assumptions about the
192 // ID, because numbering is based on a global.
193 int ConsumeRequestResource() {
194 if (message_queue_.empty()) {
195 ADD_FAILURE() << "Missing resource request message";
196 return -1;
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]197 }
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]198
199 ResourceHostMsg_RequestResource::Param params;
200 if (ResourceHostMsg_RequestResource::ID != message_queue_[0].type() ||
201 !ResourceHostMsg_RequestResource::Read(&message_queue_[0], &params)) {
202 ADD_FAILURE() << "Expected ResourceHostMsg_RequestResource message";
203 return -1;
204 }
brettwd5ca2bc2015-05-29 22:15:47[diff] [blame]205 ResourceHostMsg_Request request = base::get<2>(params);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]206 EXPECT_EQ(kTestPageUrl, request.url.spec());
207 message_queue_.erase(message_queue_.begin());
brettwd5ca2bc2015-05-29 22:15:47[diff] [blame]208 return base::get<1>(params);
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]209 }
210
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]211 void ConsumeFollowRedirect(int expected_request_id) {
212 ASSERT_FALSE(message_queue_.empty());
brettwd5ca2bc2015-05-29 22:15:47[diff] [blame]213 base::Tuple<int> args;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]214 ASSERT_EQ(ResourceHostMsg_FollowRedirect::ID, message_queue_[0].type());
215 ASSERT_TRUE(ResourceHostMsg_FollowRedirect::Read(
216 &message_queue_[0], &args));
brettwd5ca2bc2015-05-29 22:15:47[diff] [blame]217 EXPECT_EQ(expected_request_id, base::get<0>(args));
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]218 message_queue_.erase(message_queue_.begin());
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]219 }
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]220
221 void ConsumeDataReceived_ACK(int expected_request_id) {
222 ASSERT_FALSE(message_queue_.empty());
brettwd5ca2bc2015-05-29 22:15:47[diff] [blame]223 base::Tuple<int> args;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]224 ASSERT_EQ(ResourceHostMsg_DataReceived_ACK::ID, message_queue_[0].type());
225 ASSERT_TRUE(ResourceHostMsg_DataReceived_ACK::Read(
226 &message_queue_[0], &args));
brettwd5ca2bc2015-05-29 22:15:47[diff] [blame]227 EXPECT_EQ(expected_request_id, base::get<0>(args));
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]228 message_queue_.erase(message_queue_.begin());
229 }
230
231 void ConsumeDataDownloaded_ACK(int expected_request_id) {
232 ASSERT_FALSE(message_queue_.empty());
brettwd5ca2bc2015-05-29 22:15:47[diff] [blame]233 base::Tuple<int> args;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]234 ASSERT_EQ(ResourceHostMsg_DataDownloaded_ACK::ID, message_queue_[0].type());
235 ASSERT_TRUE(ResourceHostMsg_DataDownloaded_ACK::Read(
236 &message_queue_[0], &args));
brettwd5ca2bc2015-05-29 22:15:47[diff] [blame]237 EXPECT_EQ(expected_request_id, base::get<0>(args));
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]238 message_queue_.erase(message_queue_.begin());
239 }
240
241 void ConsumeReleaseDownloadedFile(int expected_request_id) {
242 ASSERT_FALSE(message_queue_.empty());
brettwd5ca2bc2015-05-29 22:15:47[diff] [blame]243 base::Tuple<int> args;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]244 ASSERT_EQ(ResourceHostMsg_ReleaseDownloadedFile::ID,
245 message_queue_[0].type());
246 ASSERT_TRUE(ResourceHostMsg_ReleaseDownloadedFile::Read(
247 &message_queue_[0], &args));
brettwd5ca2bc2015-05-29 22:15:47[diff] [blame]248 EXPECT_EQ(expected_request_id, base::get<0>(args));
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]249 message_queue_.erase(message_queue_.begin());
250 }
251
252 void ConsumeCancelRequest(int expected_request_id) {
253 ASSERT_FALSE(message_queue_.empty());
brettwd5ca2bc2015-05-29 22:15:47[diff] [blame]254 base::Tuple<int> args;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]255 ASSERT_EQ(ResourceHostMsg_CancelRequest::ID, message_queue_[0].type());
256 ASSERT_TRUE(ResourceHostMsg_CancelRequest::Read(
257 &message_queue_[0], &args));
brettwd5ca2bc2015-05-29 22:15:47[diff] [blame]258 EXPECT_EQ(expected_request_id, base::get<0>(args));
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]259 message_queue_.erase(message_queue_.begin());
260 }
261
262 void NotifyReceivedRedirect(int request_id) {
263 ResourceResponseHead head;
264 std::string raw_headers(kTestRedirectHeaders);
265 std::replace(raw_headers.begin(), raw_headers.end(), '\n', '\0');
266 head.headers = new net::HttpResponseHeaders(raw_headers);
[email protected]cba24642014-08-15 20:49:59[diff] [blame]267 net::RedirectInfo redirect_info;
268 redirect_info.status_code = 302;
269 redirect_info.new_method = "GET";
270 redirect_info.new_url = GURL(kTestPageUrl);
271 redirect_info.new_first_party_for_cookies = GURL(kTestPageUrl);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]272 EXPECT_EQ(true, dispatcher_.OnMessageReceived(
[email protected]cba24642014-08-15 20:49:59[diff] [blame]273 ResourceMsg_ReceivedRedirect(request_id, redirect_info, head)));
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]274 }
275
276 void NotifyReceivedResponse(int request_id) {
277 ResourceResponseHead head;
278 std::string raw_headers(kTestPageHeaders);
279 std::replace(raw_headers.begin(), raw_headers.end(), '\n', '\0');
280 head.headers = new net::HttpResponseHeaders(raw_headers);
281 head.mime_type = kTestPageMimeType;
282 head.charset = kTestPageCharset;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]283 EXPECT_EQ(true,
284 dispatcher_.OnMessageReceived(
285 ResourceMsg_ReceivedResponse(request_id, head)));
286 }
287
288 void NotifySetDataBuffer(int request_id, size_t buffer_size) {
289 base::SharedMemory* shared_memory = new base::SharedMemory();
290 ASSERT_FALSE(shared_memory_map_[request_id]);
291 shared_memory_map_[request_id] = shared_memory;
292 EXPECT_TRUE(shared_memory->CreateAndMapAnonymous(buffer_size));
293
294 base::SharedMemoryHandle duplicate_handle;
rvargas079d1842014-10-17 22:32:16[diff] [blame]295 EXPECT_TRUE(shared_memory->ShareToProcess(base::GetCurrentProcessHandle(),
296 &duplicate_handle));
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]297 EXPECT_TRUE(dispatcher_.OnMessageReceived(
298 ResourceMsg_SetDataBuffer(request_id, duplicate_handle,
299 shared_memory->requested_size(), 0)));
300 }
301
ki.stfu7cf10ca2015-09-27 08:37:01[diff] [blame^]302 void NotifyDataReceived(int request_id, const std::string& data) {
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]303 ASSERT_LE(data.length(), shared_memory_map_[request_id]->requested_size());
304 memcpy(shared_memory_map_[request_id]->memory(), data.c_str(),
305 data.length());
306
erikchen9064a252015-09-20 22:30:02[diff] [blame]307 EXPECT_TRUE(dispatcher_.OnMessageReceived(
308 ResourceMsg_DataReceived(request_id, 0, data.length(), data.length())));
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]309 }
310
311 void NotifyDataDownloaded(int request_id, int decoded_length,
312 int encoded_length) {
313 EXPECT_TRUE(dispatcher_.OnMessageReceived(
314 ResourceMsg_DataDownloaded(request_id, decoded_length,
315 encoded_length)));
316 }
317
318 void NotifyRequestComplete(int request_id, size_t total_size) {
319 ResourceMsg_RequestCompleteData request_complete_data;
320 request_complete_data.error_code = net::OK;
321 request_complete_data.was_ignored_by_handler = false;
322 request_complete_data.exists_in_cache = false;
323 request_complete_data.encoded_data_length = total_size;
324 EXPECT_TRUE(dispatcher_.OnMessageReceived(
325 ResourceMsg_RequestComplete(request_id, request_complete_data)));
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]326 }
327
jam4a1511ef2015-02-19 20:29:17[diff] [blame]328 RequestInfo* CreateRequestInfo(bool download_to_file) {
329 RequestInfo* request_info = new RequestInfo();
330 request_info->method = "GET";
331 request_info->url = GURL(kTestPageUrl);
332 request_info->first_party_for_cookies = GURL(kTestPageUrl);
333 request_info->referrer = Referrer();
334 request_info->headers = std::string();
335 request_info->load_flags = 0;
336 request_info->requestor_pid = 0;
337 request_info->request_type = RESOURCE_TYPE_SUB_RESOURCE;
338 request_info->appcache_host_id = kAppCacheNoHostId;
339 request_info->should_reset_appcache = false;
340 request_info->routing_id = 0;
341 request_info->download_to_file = download_to_file;
342 RequestExtraData extra_data;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]343
jam4a1511ef2015-02-19 20:29:17[diff] [blame]344 return request_info;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]345 }
346
347 ResourceDispatcher* dispatcher() { return &dispatcher_; }
348
349 private:
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]350 // Map of request IDs to shared memory.
351 std::map<int, base::SharedMemory*> shared_memory_map_;
352
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]353 std::vector<IPC::Message> message_queue_;
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]354 base::MessageLoop message_loop_;
alexclarke0bc36e8d32014-12-17 17:29:20[diff] [blame]355 ResourceDispatcher dispatcher_;
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]356};
357
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]358// Does a simple request and tests that the correct data is received. Simulates
359// two reads.
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]360TEST_F(ResourceDispatcherTest, RoundTrip) {
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]361 // Number of bytes received in the first read.
362 const size_t kFirstReceiveSize = 2;
363 ASSERT_LT(kFirstReceiveSize, strlen(kTestPageContents));
364
jam4a1511ef2015-02-19 20:29:17[diff] [blame]365 scoped_ptr<RequestInfo> request_info(CreateRequestInfo(false));
366 TestRequestPeer peer(dispatcher());
367 int request_id = dispatcher()->StartAsync(*request_info.get(), NULL, &peer);
368 peer.set_request_id(request_id);
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]369
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]370 int id = ConsumeRequestResource();
371 EXPECT_EQ(0u, queued_messages());
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]372
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]373 NotifyReceivedResponse(id);
374 EXPECT_EQ(0u, queued_messages());
375 EXPECT_TRUE(peer.received_response());
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]376
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]377 NotifySetDataBuffer(id, strlen(kTestPageContents));
378 NotifyDataReceived(id, std::string(kTestPageContents, kFirstReceiveSize));
379 ConsumeDataReceived_ACK(id);
380 EXPECT_EQ(0u, queued_messages());
381
382 NotifyDataReceived(id, kTestPageContents + kFirstReceiveSize);
383 ConsumeDataReceived_ACK(id);
384 EXPECT_EQ(0u, queued_messages());
385
386 NotifyRequestComplete(id, strlen(kTestPageContents));
387 EXPECT_EQ(kTestPageContents, peer.data());
388 EXPECT_TRUE(peer.complete());
389 EXPECT_EQ(0u, queued_messages());
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]390}
391
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]392// Tests that the request IDs are straight when there are two interleaving
393// requests.
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]394TEST_F(ResourceDispatcherTest, MultipleRequests) {
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]395 const char kTestPageContents2[] = "Not kTestPageContents";
396
jam4a1511ef2015-02-19 20:29:17[diff] [blame]397 scoped_ptr<RequestInfo> request_info1(CreateRequestInfo(false));
398 TestRequestPeer peer1(dispatcher());
399 int request_id1 = dispatcher()->StartAsync(
400 *request_info1.get(), NULL, &peer1);
401 peer1.set_request_id(request_id1);
402 scoped_ptr<RequestInfo> request_info2(CreateRequestInfo(false));
403 TestRequestPeer peer2(dispatcher());
404 int request_id2 = dispatcher()->StartAsync(
405 *request_info1.get(), NULL, &peer2);
406 peer2.set_request_id(request_id2);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]407
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]408 int id1 = ConsumeRequestResource();
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]409 int id2 = ConsumeRequestResource();
410 EXPECT_EQ(0u, queued_messages());
411
412 NotifyReceivedResponse(id1);
413 EXPECT_TRUE(peer1.received_response());
414 EXPECT_FALSE(peer2.received_response());
415 NotifyReceivedResponse(id2);
416 EXPECT_TRUE(peer2.received_response());
417 EXPECT_EQ(0u, queued_messages());
418
419 NotifySetDataBuffer(id2, strlen(kTestPageContents2));
420 NotifyDataReceived(id2, kTestPageContents2);
421 ConsumeDataReceived_ACK(id2);
422 NotifySetDataBuffer(id1, strlen(kTestPageContents));
423 NotifyDataReceived(id1, kTestPageContents);
424 ConsumeDataReceived_ACK(id1);
425 EXPECT_EQ(0u, queued_messages());
426
427 NotifyRequestComplete(id1, strlen(kTestPageContents));
428 EXPECT_EQ(kTestPageContents, peer1.data());
429 EXPECT_TRUE(peer1.complete());
430 EXPECT_FALSE(peer2.complete());
431
432 NotifyRequestComplete(id2, strlen(kTestPageContents2));
433 EXPECT_EQ(kTestPageContents2, peer2.data());
434 EXPECT_TRUE(peer2.complete());
435
436 EXPECT_EQ(0u, queued_messages());
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]437}
438
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]439// Tests that the cancel method prevents other messages from being received.
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]440TEST_F(ResourceDispatcherTest, Cancel) {
jam4a1511ef2015-02-19 20:29:17[diff] [blame]441 scoped_ptr<RequestInfo> request_info(CreateRequestInfo(false));
442 TestRequestPeer peer(dispatcher());
443 int request_id = dispatcher()->StartAsync(*request_info.get(), NULL, &peer);
444 peer.set_request_id(request_id);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]445
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]446 int id = ConsumeRequestResource();
447 EXPECT_EQ(0u, queued_messages());
448
449 // Cancel the request.
jam4a1511ef2015-02-19 20:29:17[diff] [blame]450 dispatcher()->Cancel(request_id);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]451 ConsumeCancelRequest(id);
452
453 // Any future messages related to the request should be ignored.
454 NotifyReceivedResponse(id);
455 NotifySetDataBuffer(id, strlen(kTestPageContents));
456 NotifyDataReceived(id, kTestPageContents);
457 NotifyRequestComplete(id, strlen(kTestPageContents));
458
459 EXPECT_EQ(0u, queued_messages());
460 EXPECT_EQ("", peer.data());
461 EXPECT_FALSE(peer.received_response());
462 EXPECT_FALSE(peer.complete());
463}
464
465// Tests that calling cancel during a callback works as expected.
466TEST_F(ResourceDispatcherTest, CancelDuringCallback) {
jam4a1511ef2015-02-19 20:29:17[diff] [blame]467 scoped_ptr<RequestInfo> request_info(CreateRequestInfo(false));
468 TestRequestPeer peer(dispatcher());
469 int request_id = dispatcher()->StartAsync(*request_info.get(), NULL, &peer);
470 peer.set_request_id(request_id);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]471 peer.set_cancel_on_receive_response(true);
472
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]473 int id = ConsumeRequestResource();
474 EXPECT_EQ(0u, queued_messages());
475
476 NotifyReceivedResponse(id);
477 EXPECT_TRUE(peer.received_response());
478 // Request should have been cancelled.
479 ConsumeCancelRequest(id);
480
481 // Any future messages related to the request should be ignored.
482 NotifySetDataBuffer(id, strlen(kTestPageContents));
483 NotifyDataReceived(id, kTestPageContents);
484 NotifyRequestComplete(id, strlen(kTestPageContents));
485
486 EXPECT_EQ(0u, queued_messages());
487 EXPECT_EQ("", peer.data());
488 EXPECT_FALSE(peer.complete());
489}
490
491// Checks that redirects work as expected.
492TEST_F(ResourceDispatcherTest, Redirect) {
jam4a1511ef2015-02-19 20:29:17[diff] [blame]493 scoped_ptr<RequestInfo> request_info(CreateRequestInfo(false));
494 TestRequestPeer peer(dispatcher());
495 int request_id = dispatcher()->StartAsync(*request_info.get(), NULL, &peer);
496 peer.set_request_id(request_id);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]497
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]498 int id = ConsumeRequestResource();
499
500 NotifyReceivedRedirect(id);
501 ConsumeFollowRedirect(id);
502 EXPECT_EQ(1, peer.seen_redirects());
503
504 NotifyReceivedRedirect(id);
505 ConsumeFollowRedirect(id);
506 EXPECT_EQ(2, peer.seen_redirects());
507
508 NotifyReceivedResponse(id);
509 EXPECT_TRUE(peer.received_response());
510
511 NotifySetDataBuffer(id, strlen(kTestPageContents));
512 NotifyDataReceived(id, kTestPageContents);
513 ConsumeDataReceived_ACK(id);
514
515 NotifyRequestComplete(id, strlen(kTestPageContents));
516 EXPECT_EQ(kTestPageContents, peer.data());
517 EXPECT_TRUE(peer.complete());
518 EXPECT_EQ(0u, queued_messages());
519 EXPECT_EQ(2, peer.seen_redirects());
520}
521
522// Tests that that cancelling during a redirect method prevents other messages
523// from being received.
524TEST_F(ResourceDispatcherTest, CancelDuringRedirect) {
jam4a1511ef2015-02-19 20:29:17[diff] [blame]525 scoped_ptr<RequestInfo> request_info(CreateRequestInfo(false));
526 TestRequestPeer peer(dispatcher());
527 int request_id = dispatcher()->StartAsync(*request_info.get(), NULL, &peer);
528 peer.set_request_id(request_id);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]529 peer.set_follow_redirects(false);
530
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]531 int id = ConsumeRequestResource();
532 EXPECT_EQ(0u, queued_messages());
533
534 // Redirect the request, which triggers a cancellation.
535 NotifyReceivedRedirect(id);
536 ConsumeCancelRequest(id);
537 EXPECT_EQ(1, peer.seen_redirects());
538 EXPECT_EQ(0u, queued_messages());
539
540 // Any future messages related to the request should be ignored. In practice,
541 // only the NotifyRequestComplete should be received after this point.
542 NotifyReceivedRedirect(id);
543 NotifyReceivedResponse(id);
544 NotifySetDataBuffer(id, strlen(kTestPageContents));
545 NotifyDataReceived(id, kTestPageContents);
546 NotifyRequestComplete(id, strlen(kTestPageContents));
547
548 EXPECT_EQ(0u, queued_messages());
549 EXPECT_EQ("", peer.data());
550 EXPECT_FALSE(peer.complete());
551 EXPECT_EQ(1, peer.seen_redirects());
552}
553
554// Checks that deferring a request delays messages until it's resumed.
555TEST_F(ResourceDispatcherTest, Defer) {
jam4a1511ef2015-02-19 20:29:17[diff] [blame]556 scoped_ptr<RequestInfo> request_info(CreateRequestInfo(false));
557 TestRequestPeer peer(dispatcher());
558 int request_id = dispatcher()->StartAsync(*request_info.get(), NULL, &peer);
559 peer.set_request_id(request_id);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]560
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]561 int id = ConsumeRequestResource();
562 EXPECT_EQ(0u, queued_messages());
563
jam4a1511ef2015-02-19 20:29:17[diff] [blame]564 dispatcher()->SetDefersLoading(request_id, true);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]565 NotifyReceivedResponse(id);
566 NotifySetDataBuffer(id, strlen(kTestPageContents));
567 NotifyDataReceived(id, kTestPageContents);
568 NotifyRequestComplete(id, strlen(kTestPageContents));
569
570 // None of the messages should have been processed yet, so no queued messages
571 // to the browser process, and no data received by the peer.
572 EXPECT_EQ(0u, queued_messages());
573 EXPECT_EQ("", peer.data());
574 EXPECT_FALSE(peer.complete());
575 EXPECT_EQ(0, peer.seen_redirects());
576
577 // Resuming the request should asynchronously unleash the deferred messages.
jam4a1511ef2015-02-19 20:29:17[diff] [blame]578 dispatcher()->SetDefersLoading(request_id, false);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]579 base::RunLoop().RunUntilIdle();
580
581 ConsumeDataReceived_ACK(id);
582 EXPECT_EQ(0u, queued_messages());
583 EXPECT_TRUE(peer.received_response());
584 EXPECT_EQ(kTestPageContents, peer.data());
585 EXPECT_TRUE(peer.complete());
586}
587
588// Checks that deferring a request during a redirect delays messages until it's
589// resumed.
590TEST_F(ResourceDispatcherTest, DeferOnRedirect) {
jam4a1511ef2015-02-19 20:29:17[diff] [blame]591 scoped_ptr<RequestInfo> request_info(CreateRequestInfo(false));
592 TestRequestPeer peer(dispatcher());
593 int request_id = dispatcher()->StartAsync(*request_info.get(), NULL, &peer);
594 peer.set_request_id(request_id);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]595 peer.set_defer_on_redirect(true);
596
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]597 int id = ConsumeRequestResource();
598 EXPECT_EQ(0u, queued_messages());
599
600 // The request should be deferred during the redirect, including the message
601 // to follow the redirect.
602 NotifyReceivedRedirect(id);
603 NotifyReceivedResponse(id);
604 NotifySetDataBuffer(id, strlen(kTestPageContents));
605 NotifyDataReceived(id, kTestPageContents);
606 NotifyRequestComplete(id, strlen(kTestPageContents));
607
608 // None of the messages should have been processed yet, so no queued messages
609 // to the browser process, and no data received by the peer.
610 EXPECT_EQ(0u, queued_messages());
611 EXPECT_EQ("", peer.data());
612 EXPECT_FALSE(peer.complete());
613 EXPECT_EQ(1, peer.seen_redirects());
614
615 // Resuming the request should asynchronously unleash the deferred messages.
jam4a1511ef2015-02-19 20:29:17[diff] [blame]616 dispatcher()->SetDefersLoading(request_id, false);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]617 base::RunLoop().RunUntilIdle();
618
619 ConsumeFollowRedirect(id);
620 ConsumeDataReceived_ACK(id);
621
622 EXPECT_EQ(0u, queued_messages());
623 EXPECT_TRUE(peer.received_response());
624 EXPECT_EQ(kTestPageContents, peer.data());
625 EXPECT_TRUE(peer.complete());
626 EXPECT_EQ(1, peer.seen_redirects());
627}
628
629// Checks that a deferred request that's cancelled doesn't receive any messages.
630TEST_F(ResourceDispatcherTest, CancelDeferredRequest) {
jam4a1511ef2015-02-19 20:29:17[diff] [blame]631 scoped_ptr<RequestInfo> request_info(CreateRequestInfo(false));
632 TestRequestPeer peer(dispatcher());
633 int request_id = dispatcher()->StartAsync(*request_info.get(), NULL, &peer);
634 peer.set_request_id(request_id);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]635
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]636 int id = ConsumeRequestResource();
637 EXPECT_EQ(0u, queued_messages());
638
jam4a1511ef2015-02-19 20:29:17[diff] [blame]639 dispatcher()->SetDefersLoading(request_id, true);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]640 NotifyReceivedRedirect(id);
jam4a1511ef2015-02-19 20:29:17[diff] [blame]641 dispatcher()->Cancel(request_id);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]642 ConsumeCancelRequest(id);
643
644 NotifyRequestComplete(id, 0);
645 base::RunLoop().RunUntilIdle();
646
647 // None of the messages should have been processed.
648 EXPECT_EQ(0u, queued_messages());
649 EXPECT_EQ("", peer.data());
650 EXPECT_FALSE(peer.complete());
651 EXPECT_EQ(0, peer.seen_redirects());
652}
653
654TEST_F(ResourceDispatcherTest, DownloadToFile) {
jam4a1511ef2015-02-19 20:29:17[diff] [blame]655 scoped_ptr<RequestInfo> request_info(CreateRequestInfo(true));
656 TestRequestPeer peer(dispatcher());
657 int request_id = dispatcher()->StartAsync(*request_info.get(), NULL, &peer);
658 peer.set_request_id(request_id);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]659 const int kDownloadedIncrement = 100;
660 const int kEncodedIncrement = 50;
661
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]662 int id = ConsumeRequestResource();
663 EXPECT_EQ(0u, queued_messages());
664
665 NotifyReceivedResponse(id);
666 EXPECT_EQ(0u, queued_messages());
667 EXPECT_TRUE(peer.received_response());
668
669 int expected_total_downloaded_length = 0;
670 int expected_total_encoded_length = 0;
671 for (int i = 0; i < 10; ++i) {
672 NotifyDataDownloaded(id, kDownloadedIncrement, kEncodedIncrement);
673 ConsumeDataDownloaded_ACK(id);
674 expected_total_downloaded_length += kDownloadedIncrement;
675 expected_total_encoded_length += kEncodedIncrement;
676 EXPECT_EQ(expected_total_downloaded_length,
677 peer.total_downloaded_data_length());
678 EXPECT_EQ(expected_total_encoded_length, peer.total_encoded_data_length());
679 }
680
681 NotifyRequestComplete(id, strlen(kTestPageContents));
682 EXPECT_EQ("", peer.data());
683 EXPECT_TRUE(peer.complete());
684 EXPECT_EQ(0u, queued_messages());
685
jam4a1511ef2015-02-19 20:29:17[diff] [blame]686 dispatcher()->RemovePendingRequest(request_id);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]687 ConsumeReleaseDownloadedFile(id);
688 EXPECT_EQ(0u, queued_messages());
689 EXPECT_EQ(expected_total_downloaded_length,
690 peer.total_downloaded_data_length());
691 EXPECT_EQ(expected_total_encoded_length, peer.total_encoded_data_length());
692}
693
694// Make sure that when a download to file is cancelled, the file is destroyed.
695TEST_F(ResourceDispatcherTest, CancelDownloadToFile) {
jam4a1511ef2015-02-19 20:29:17[diff] [blame]696 scoped_ptr<RequestInfo> request_info(CreateRequestInfo(true));
697 TestRequestPeer peer(dispatcher());
698 int request_id = dispatcher()->StartAsync(*request_info.get(), NULL, &peer);
699 peer.set_request_id(request_id);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]700
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]701 int id = ConsumeRequestResource();
702 EXPECT_EQ(0u, queued_messages());
703
704 NotifyReceivedResponse(id);
705 EXPECT_EQ(0u, queued_messages());
706 EXPECT_TRUE(peer.received_response());
707
708 // Cancelling the request deletes the file.
jam4a1511ef2015-02-19 20:29:17[diff] [blame]709 dispatcher()->Cancel(request_id);
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]710 ConsumeCancelRequest(id);
711 ConsumeReleaseDownloadedFile(id);
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]712}
713
714TEST_F(ResourceDispatcherTest, Cookies) {
715 // FIXME
716}
717
718TEST_F(ResourceDispatcherTest, SerializedPostData) {
719 // FIXME
720}
[email protected]2602087e2009-08-24 23:12:16[diff] [blame]721
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]722class TimeConversionTest : public ResourceDispatcherTest,
[email protected]ddf55bb2014-04-03 08:24:47[diff] [blame]723 public RequestPeer {
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]724 public:
dchenge933b3e2014-10-21 11:44:09[diff] [blame]725 bool Send(IPC::Message* msg) override {
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]726 delete msg;
727 return true;
728 }
729
730 void PerformTest(const ResourceResponseHead& response_head) {
jam4a1511ef2015-02-19 20:29:17[diff] [blame]731 scoped_ptr<RequestInfo> request_info(CreateRequestInfo(false));
732 TestRequestPeer peer(dispatcher());
733 dispatcher()->StartAsync(*request_info.get(), NULL, &peer);
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]734
[email protected]0a0e2c7b2014-06-16 19:10:14[diff] [blame]735 dispatcher()->OnMessageReceived(
[email protected]f4653192013-09-06 19:24:05[diff] [blame]736 ResourceMsg_ReceivedResponse(0, response_head));
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]737 }
738
[email protected]ddf55bb2014-04-03 08:24:47[diff] [blame]739 // RequestPeer methods.
dchenge933b3e2014-10-21 11:44:09[diff] [blame]740 void OnUploadProgress(uint64 position, uint64 size) override {}
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]741
dchenge933b3e2014-10-21 11:44:09[diff] [blame]742 bool OnReceivedRedirect(const net::RedirectInfo& redirect_info,
743 const ResourceResponseInfo& info) override {
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]744 return true;
745 }
746
dchenge933b3e2014-10-21 11:44:09[diff] [blame]747 void OnReceivedResponse(const ResourceResponseInfo& info) override {
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]748 response_info_ = info;
749 }
750
dchenge933b3e2014-10-21 11:44:09[diff] [blame]751 void OnDownloadedData(int len, int encoded_data_length) override {}
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]752
yhiranof0a364e2015-06-03 04:49:50[diff] [blame]753 void OnReceivedData(scoped_ptr<ReceivedData> data) override {}
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]754
dchenge933b3e2014-10-21 11:44:09[diff] [blame]755 void OnCompletedRequest(int error_code,
756 bool was_ignored_by_handler,
757 bool stale_copy_in_cache,
758 const std::string& security_info,
759 const base::TimeTicks& completion_time,
760 int64 total_transfer_size) override {}
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]761
yhirano33187ed2015-07-08 05:22:11[diff] [blame]762 void OnReceivedCompletedResponse(const ResourceResponseInfo& info,
763 scoped_ptr<ReceivedData> data,
764 int error_code,
765 bool was_ignored_by_handler,
766 bool stale_copy_in_cache,
767 const std::string& security_info,
768 const base::TimeTicks& completion_time,
769 int64 total_transfer_size) override {}
770
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]771 const ResourceResponseInfo& response_info() const { return response_info_; }
772
773 private:
774 ResourceResponseInfo response_info_;
775};
776
777// TODO(simonjam): Enable this when 10829031 lands.
778TEST_F(TimeConversionTest, DISABLED_ProperlyInitialized) {
779 ResourceResponseHead response_head;
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]780 response_head.request_start = base::TimeTicks::FromInternalValue(5);
781 response_head.response_start = base::TimeTicks::FromInternalValue(15);
[email protected]ec298802013-03-27 16:45:07[diff] [blame]782 response_head.load_timing.request_start_time = base::Time::Now();
783 response_head.load_timing.request_start =
784 base::TimeTicks::FromInternalValue(10);
785 response_head.load_timing.connect_timing.connect_start =
786 base::TimeTicks::FromInternalValue(13);
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]787
788 PerformTest(response_head);
789
[email protected]ec298802013-03-27 16:45:07[diff] [blame]790 EXPECT_LT(base::TimeTicks(), response_info().load_timing.request_start);
791 EXPECT_EQ(base::TimeTicks(),
792 response_info().load_timing.connect_timing.dns_start);
793 EXPECT_LE(response_head.load_timing.request_start,
794 response_info().load_timing.connect_timing.connect_start);
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]795}
796
797TEST_F(TimeConversionTest, PartiallyInitialized) {
798 ResourceResponseHead response_head;
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]799 response_head.request_start = base::TimeTicks::FromInternalValue(5);
800 response_head.response_start = base::TimeTicks::FromInternalValue(15);
801
802 PerformTest(response_head);
803
[email protected]ec298802013-03-27 16:45:07[diff] [blame]804 EXPECT_EQ(base::TimeTicks(), response_info().load_timing.request_start);
805 EXPECT_EQ(base::TimeTicks(),
806 response_info().load_timing.connect_timing.dns_start);
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]807}
808
809TEST_F(TimeConversionTest, NotInitialized) {
810 ResourceResponseHead response_head;
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]811
812 PerformTest(response_head);
813
[email protected]ec298802013-03-27 16:45:07[diff] [blame]814 EXPECT_EQ(base::TimeTicks(), response_info().load_timing.request_start);
815 EXPECT_EQ(base::TimeTicks(),
816 response_info().load_timing.connect_timing.dns_start);
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]817}
818
[email protected]be7b41e82012-07-04 09:46:51[diff] [blame]819} // namespace content