Google Git
Sign in
chromium / chromium / src.git / dcbe3df77892fded9f0afa3fe01112f242b6fff7 / . / content / child / resource_dispatcher_unittest.cc
blob: 7ff9ac3357dc192da4a798710c916197085e5221 [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]3b63f8f42011-03-28 01:54:15[diff] [blame]8#include "base/memory/scoped_ptr.h"
[email protected]e55f5642013-07-18 00:22:54[diff] [blame]9#include "base/message_loop/message_loop.h"
[email protected]54724e22013-07-25 13:02:15[diff] [blame]10#include "base/process/process.h"
11#include "base/process/process_handle.h"
[email protected]541b7b02013-06-07 00:59:34[diff] [blame]12#include "content/child/request_extra_data.h"
[email protected]10208ea2013-06-06 20:08:03[diff] [blame]13#include "content/child/resource_dispatcher.h"
[email protected]94dc971d2011-03-05 19:08:32[diff] [blame]14#include "content/common/resource_messages.h"
[email protected]2336ffe2011-11-24 01:23:34[diff] [blame]15#include "content/public/common/resource_response.h"
[email protected]2756a8e2012-09-07 18:24:29[diff] [blame]16#include "net/base/net_errors.h"
[email protected]7a4de7a62010-08-17 18:38:24[diff] [blame]17#include "net/http/http_response_headers.h"
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]18#include "testing/gtest/include/gtest/gtest.h"
[email protected]d5b2fdf2013-06-05 09:36:55[diff] [blame]19#include "webkit/common/appcache/appcache_interfaces.h"
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]20
21using webkit_glue::ResourceLoaderBridge;
[email protected]b4b3a912010-10-08 19:05:37[diff] [blame]22using webkit_glue::ResourceResponseInfo;
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]23
[email protected]be7b41e82012-07-04 09:46:51[diff] [blame]24namespace content {
25
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]26static const char test_page_url[] = "http://www.google.com/";
27static const char test_page_headers[] =
28 "HTTP/1.1 200 OK\nContent-Type:text/html\n\n";
29static const char test_page_mime_type[] = "text/html";
30static const char test_page_charset[] = "";
31static const char test_page_contents[] =
32 "<html><head><title>Google</title></head><body><h1>Google</h1></body></html>";
[email protected]b5ab3982010-02-16 23:58:27[diff] [blame]33static const uint32 test_page_contents_len = arraysize(test_page_contents) - 1;
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]34
[email protected]b8901082010-11-12 01:14:28[diff] [blame]35static const char kShmemSegmentName[] = "DeferredResourceLoaderTest";
36
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]37// Listens for request response data and stores it so that it can be compared
38// to the reference data.
39class TestRequestCallback : public ResourceLoaderBridge::Peer {
40 public:
41 TestRequestCallback() : complete_(false) {
42 }
43
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]44 virtual void OnUploadProgress(uint64 position, uint64 size) OVERRIDE {
[email protected]bb551622010-07-22 20:52:49[diff] [blame]45 }
46
[email protected]6568a9e32009-07-30 18:01:39[diff] [blame]47 virtual bool OnReceivedRedirect(
48 const GURL& new_url,
[email protected]b4b3a912010-10-08 19:05:37[diff] [blame]49 const ResourceResponseInfo& info,
[email protected]041b0bbb2009-11-18 02:27:34[diff] [blame]50 bool* has_new_first_party_for_cookies,
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]51 GURL* new_first_party_for_cookies) OVERRIDE {
[email protected]041b0bbb2009-11-18 02:27:34[diff] [blame]52 *has_new_first_party_for_cookies = false;
[email protected]6568a9e32009-07-30 18:01:39[diff] [blame]53 return true;
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]54 }
55
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]56 virtual void OnReceivedResponse(const ResourceResponseInfo& info) OVERRIDE {
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]57 }
58
[email protected]ad554bc2013-09-03 21:18:47[diff] [blame]59 virtual void OnDownloadedData(int len, int encoded_data_length) OVERRIDE {
[email protected]bb551622010-07-22 20:52:49[diff] [blame]60 }
61
[email protected]8bd0de72011-04-08 18:52:10[diff] [blame]62 virtual void OnReceivedData(const char* data,
63 int data_length,
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]64 int encoded_data_length) OVERRIDE {
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]65 EXPECT_FALSE(complete_);
[email protected]8bd0de72011-04-08 18:52:10[diff] [blame]66 data_.append(data, data_length);
[email protected]dfd682172011-04-13 19:57:25[diff] [blame]67 total_encoded_data_length_ += encoded_data_length;
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]68 }
69
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]70 virtual void OnCompletedRequest(
[email protected]2756a8e2012-09-07 18:24:29[diff] [blame]71 int error_code,
72 bool was_ignored_by_handler,
[email protected]dcbe3df2014-02-06 23:08:37[diff] [blame^]73 bool stale_copy_in_cache,
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]74 const std::string& security_info,
[email protected]c3e35892013-02-12 02:08:01[diff] [blame]75 const base::TimeTicks& completion_time) OVERRIDE {
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]76 EXPECT_FALSE(complete_);
77 complete_ = true;
78 }
79
[email protected]8bd0de72011-04-08 18:52:10[diff] [blame]80 bool complete() const {
81 return complete_;
82 }
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]83 const std::string& data() const {
84 return data_;
85 }
[email protected]dfd682172011-04-13 19:57:25[diff] [blame]86 int total_encoded_data_length() const {
87 return total_encoded_data_length_;
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]88 }
89
90 private:
91 bool complete_;
92 std::string data_;
[email protected]dfd682172011-04-13 19:57:25[diff] [blame]93 int total_encoded_data_length_;
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]94};
95
96
97// Sets up the message sender override for the unit test
[email protected]d84effeb2012-06-25 17:03:10[diff] [blame]98class ResourceDispatcherTest : public testing::Test, public IPC::Sender {
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]99 public:
[email protected]d84effeb2012-06-25 17:03:10[diff] [blame]100 // Emulates IPC send operations (IPC::Sender) by adding
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]101 // pending messages to the queue.
[email protected]c3e35892013-02-12 02:08:01[diff] [blame]102 virtual bool Send(IPC::Message* msg) OVERRIDE {
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]103 message_queue_.push_back(IPC::Message(*msg));
104 delete msg;
105 return true;
106 }
107
108 // Emulates the browser process and processes the pending IPC messages,
109 // returning the hardcoded file contents.
110 void ProcessMessages() {
111 while (!message_queue_.empty()) {
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]112 int request_id;
[email protected]94dc971d2011-03-05 19:08:32[diff] [blame]113 ResourceHostMsg_Request request;
114 ASSERT_TRUE(ResourceHostMsg_RequestResource::Read(
[email protected]eb9989092009-03-12 21:42:52[diff] [blame]115 &message_queue_[0], &request_id, &request));
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]116
117 // check values
118 EXPECT_EQ(test_page_url, request.url.spec());
119
120 // received response message
[email protected]be7b41e82012-07-04 09:46:51[diff] [blame]121 ResourceResponseHead response;
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]122 std::string raw_headers(test_page_headers);
123 std::replace(raw_headers.begin(), raw_headers.end(), '\n', '\0');
124 response.headers = new net::HttpResponseHeaders(raw_headers);
125 response.mime_type = test_page_mime_type;
126 response.charset = test_page_charset;
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]127 dispatcher_->OnReceivedResponse(request_id, response);
128
129 // received data message with the test contents
[email protected]176aa482008-11-14 03:25:15[diff] [blame]130 base::SharedMemory shared_mem;
[email protected]54e3dfa22010-10-27 18:16:06[diff] [blame]131 EXPECT_TRUE(shared_mem.CreateAndMapAnonymous(test_page_contents_len));
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]132 char* put_data_here = static_cast<char*>(shared_mem.memory());
133 memcpy(put_data_here, test_page_contents, test_page_contents_len);
[email protected]176aa482008-11-14 03:25:15[diff] [blame]134 base::SharedMemoryHandle dup_handle;
[email protected]4003d7142009-01-12 12:56:20[diff] [blame]135 EXPECT_TRUE(shared_mem.GiveToProcess(
136 base::Process::Current().handle(), &dup_handle));
[email protected]f4653192013-09-06 19:24:05[diff] [blame]137 dispatcher_->OnSetDataBuffer(request_id, dup_handle,
[email protected]9d9387e2013-01-12 16:55:08[diff] [blame]138 test_page_contents_len, 0);
[email protected]f4653192013-09-06 19:24:05[diff] [blame]139 dispatcher_->OnReceivedData(request_id, 0, test_page_contents_len,
[email protected]f0fa1ab2012-09-18 06:28:38[diff] [blame]140 test_page_contents_len);
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]141
142 message_queue_.erase(message_queue_.begin());
143
144 // read the ack message.
[email protected]c2fe31542009-05-20 18:24:14[diff] [blame]145 Tuple1<int> request_ack;
[email protected]94dc971d2011-03-05 19:08:32[diff] [blame]146 ASSERT_TRUE(ResourceHostMsg_DataReceived_ACK::Read(
[email protected]eb9989092009-03-12 21:42:52[diff] [blame]147 &message_queue_[0], &request_ack));
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]148
[email protected]c2fe31542009-05-20 18:24:14[diff] [blame]149 ASSERT_EQ(request_ack.a, request_id);
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]150
151 message_queue_.erase(message_queue_.begin());
152 }
153 }
154
155 protected:
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]156 // testing::Test
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]157 virtual void SetUp() OVERRIDE {
[email protected]eb9989092009-03-12 21:42:52[diff] [blame]158 dispatcher_.reset(new ResourceDispatcher(this));
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]159 }
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]160 virtual void TearDown() OVERRIDE {
[email protected]eb9989092009-03-12 21:42:52[diff] [blame]161 dispatcher_.reset();
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]162 }
163
[email protected]2602087e2009-08-24 23:12:16[diff] [blame]164 ResourceLoaderBridge* CreateBridge() {
[email protected]46b0d4a2009-12-19 00:46:33[diff] [blame]165 webkit_glue::ResourceLoaderBridge::RequestInfo request_info;
166 request_info.method = "GET";
167 request_info.url = GURL(test_page_url);
168 request_info.first_party_for_cookies = GURL(test_page_url);
169 request_info.referrer = GURL();
[email protected]46b0d4a2009-12-19 00:46:33[diff] [blame]170 request_info.headers = std::string();
171 request_info.load_flags = 0;
172 request_info.requestor_pid = 0;
173 request_info.request_type = ResourceType::SUB_RESOURCE;
[email protected]52bbcd932010-01-06 18:56:12[diff] [blame]174 request_info.appcache_host_id = appcache::kNoHostId;
175 request_info.routing_id = 0;
[email protected]cacbd7a2014-02-04 01:26:02[diff] [blame]176 RequestExtraData extra_data(blink::WebPageVisibilityStateVisible,
[email protected]180ef242013-11-07 06:50:46[diff] [blame]177 blink::WebString(),
[email protected]60eca4eb2013-12-06 00:02:16[diff] [blame]178 false, MSG_ROUTING_NONE, true, 0, GURL(),
[email protected]15b5a542013-08-23 23:55:37[diff] [blame]179 false, -1, true,
[email protected]4972fc82013-11-19 04:33:42[diff] [blame]180 PAGE_TRANSITION_LINK, false, -1, -1);
[email protected]940895b2011-08-20 00:50:05[diff] [blame]181 request_info.extra_data = &extra_data;
[email protected]46b0d4a2009-12-19 00:46:33[diff] [blame]182
[email protected]50285ff2011-03-11 23:10:56[diff] [blame]183 return dispatcher_->CreateBridge(request_info);
[email protected]2602087e2009-08-24 23:12:16[diff] [blame]184 }
185
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]186 std::vector<IPC::Message> message_queue_;
[email protected]eb9989092009-03-12 21:42:52[diff] [blame]187 static scoped_ptr<ResourceDispatcher> dispatcher_;
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]188};
189
190/*static*/
[email protected]eb9989092009-03-12 21:42:52[diff] [blame]191scoped_ptr<ResourceDispatcher> ResourceDispatcherTest::dispatcher_;
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]192
193// Does a simple request and tests that the correct data is received.
194TEST_F(ResourceDispatcherTest, RoundTrip) {
195 TestRequestCallback callback;
[email protected]2602087e2009-08-24 23:12:16[diff] [blame]196 ResourceLoaderBridge* bridge = CreateBridge();
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]197
198 bridge->Start(&callback);
199
200 ProcessMessages();
201
202 // FIXME(brettw) when the request complete messages are actually handledo
203 // and dispatched, uncomment this.
204 //EXPECT_TRUE(callback.complete());
205 //EXPECT_STREQ(test_page_contents, callback.data().c_str());
[email protected]dfd682172011-04-13 19:57:25[diff] [blame]206 //EXPECT_EQ(test_page_contents_len, callback.total_encoded_data_length());
initial.commit09911bf2008-07-26 23:55:29[diff] [blame]207
208 delete bridge;
209}
210
211// Tests that the request IDs are straight when there are multiple requests.
212TEST_F(ResourceDispatcherTest, MultipleRequests) {
213 // FIXME
214}
215
216// Tests that the cancel method prevents other messages from being received
217TEST_F(ResourceDispatcherTest, Cancel) {
218 // FIXME
219}
220
221TEST_F(ResourceDispatcherTest, Cookies) {
222 // FIXME
223}
224
225TEST_F(ResourceDispatcherTest, SerializedPostData) {
226 // FIXME
227}
[email protected]2602087e2009-08-24 23:12:16[diff] [blame]228
229// This class provides functionality to validate whether the ResourceDispatcher
230// object honors the deferred loading contract correctly, i.e. if deferred
231// loading is enabled it should queue up any responses received. If deferred
232// loading is enabled/disabled in the context of a dispatched message, other
233// queued messages should not be dispatched until deferred load is turned off.
234class DeferredResourceLoadingTest : public ResourceDispatcherTest,
235 public ResourceLoaderBridge::Peer {
236 public:
237 DeferredResourceLoadingTest()
238 : defer_loading_(false) {
239 }
240
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]241 virtual bool Send(IPC::Message* msg) OVERRIDE {
[email protected]2602087e2009-08-24 23:12:16[diff] [blame]242 delete msg;
243 return true;
244 }
245
246 void InitMessages() {
247 set_defer_loading(true);
248
[email protected]be7b41e82012-07-04 09:46:51[diff] [blame]249 ResourceResponseHead response_head;
[email protected]2756a8e2012-09-07 18:24:29[diff] [blame]250 response_head.error_code = net::OK;
[email protected]2602087e2009-08-24 23:12:16[diff] [blame]251
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]252 dispatcher_->OnMessageReceived(
[email protected]f4653192013-09-06 19:24:05[diff] [blame]253 ResourceMsg_ReceivedResponse(0, response_head));
[email protected]2602087e2009-08-24 23:12:16[diff] [blame]254
[email protected]a68114f72009-11-30 23:32:49[diff] [blame]255 // Duplicate the shared memory handle so both the test and the callee can
256 // close their copy.
257 base::SharedMemoryHandle duplicated_handle;
258 EXPECT_TRUE(shared_handle_.ShareToProcess(base::GetCurrentProcessHandle(),
259 &duplicated_handle));
260
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]261 dispatcher_->OnMessageReceived(
[email protected]f4653192013-09-06 19:24:05[diff] [blame]262 ResourceMsg_SetDataBuffer(0, duplicated_handle, 100, 0));
263 dispatcher_->OnMessageReceived(ResourceMsg_DataReceived(0, 0, 100, 100));
[email protected]2602087e2009-08-24 23:12:16[diff] [blame]264
265 set_defer_loading(false);
266 }
267
268 // ResourceLoaderBridge::Peer methods.
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]269 virtual void OnUploadProgress(uint64 position, uint64 size) OVERRIDE {
[email protected]2602087e2009-08-24 23:12:16[diff] [blame]270 }
271
272 virtual bool OnReceivedRedirect(
273 const GURL& new_url,
[email protected]b4b3a912010-10-08 19:05:37[diff] [blame]274 const ResourceResponseInfo& info,
[email protected]041b0bbb2009-11-18 02:27:34[diff] [blame]275 bool* has_new_first_party_for_cookies,
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]276 GURL* new_first_party_for_cookies) OVERRIDE {
[email protected]041b0bbb2009-11-18 02:27:34[diff] [blame]277 *has_new_first_party_for_cookies = false;
[email protected]2602087e2009-08-24 23:12:16[diff] [blame]278 return true;
279 }
280
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]281 virtual void OnReceivedResponse(const ResourceResponseInfo& info) OVERRIDE {
[email protected]bb551622010-07-22 20:52:49[diff] [blame]282 EXPECT_EQ(defer_loading_, false);
283 set_defer_loading(true);
284 }
285
[email protected]ad554bc2013-09-03 21:18:47[diff] [blame]286 virtual void OnDownloadedData(int len, int encoded_data_length) OVERRIDE {
[email protected]bb551622010-07-22 20:52:49[diff] [blame]287 }
288
[email protected]8bd0de72011-04-08 18:52:10[diff] [blame]289 virtual void OnReceivedData(const char* data,
290 int data_length,
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]291 int encoded_data_length) OVERRIDE {
[email protected]2602087e2009-08-24 23:12:16[diff] [blame]292 EXPECT_EQ(defer_loading_, false);
293 set_defer_loading(false);
294 }
295
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]296 virtual void OnCompletedRequest(
[email protected]2756a8e2012-09-07 18:24:29[diff] [blame]297 int error_code,
298 bool was_ignored_by_handler,
[email protected]dcbe3df2014-02-06 23:08:37[diff] [blame^]299 bool stale_copy_in_cache,
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]300 const std::string& security_info,
[email protected]c3e35892013-02-12 02:08:01[diff] [blame]301 const base::TimeTicks& completion_time) OVERRIDE {
[email protected]2602087e2009-08-24 23:12:16[diff] [blame]302 }
303
[email protected]2602087e2009-08-24 23:12:16[diff] [blame]304 protected:
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]305 virtual void SetUp() OVERRIDE {
[email protected]2602087e2009-08-24 23:12:16[diff] [blame]306 ResourceDispatcherTest::SetUp();
[email protected]b8901082010-11-12 01:14:28[diff] [blame]307 shared_handle_.Delete(kShmemSegmentName);
[email protected]515f2492011-01-14 10:36:28[diff] [blame]308 EXPECT_TRUE(shared_handle_.CreateNamed(kShmemSegmentName, false, 100));
[email protected]2602087e2009-08-24 23:12:16[diff] [blame]309 }
310
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]311 virtual void TearDown() OVERRIDE {
[email protected]2602087e2009-08-24 23:12:16[diff] [blame]312 shared_handle_.Close();
[email protected]b8901082010-11-12 01:14:28[diff] [blame]313 EXPECT_TRUE(shared_handle_.Delete(kShmemSegmentName));
[email protected]2602087e2009-08-24 23:12:16[diff] [blame]314 ResourceDispatcherTest::TearDown();
315 }
316
317 private:
318 void set_defer_loading(bool defer) {
319 defer_loading_ = defer;
320 dispatcher_->SetDefersLoading(0, defer);
321 }
322
323 bool defer_loading() const {
324 return defer_loading_;
325 }
326
327 bool defer_loading_;
328 base::SharedMemory shared_handle_;
329};
330
331TEST_F(DeferredResourceLoadingTest, DeferredLoadTest) {
[email protected]1ef90012014-01-15 22:24:33[diff] [blame]332 base::MessageLoopForIO message_loop;
[email protected]2602087e2009-08-24 23:12:16[diff] [blame]333
334 ResourceLoaderBridge* bridge = CreateBridge();
335
336 bridge->Start(this);
337 InitMessages();
338
339 // Dispatch deferred messages.
[email protected]f319ace2012-11-10 19:07:29[diff] [blame]340 message_loop.RunUntilIdle();
[email protected]2602087e2009-08-24 23:12:16[diff] [blame]341 delete bridge;
342}
[email protected]be7b41e82012-07-04 09:46:51[diff] [blame]343
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]344class TimeConversionTest : public ResourceDispatcherTest,
345 public ResourceLoaderBridge::Peer {
346 public:
347 virtual bool Send(IPC::Message* msg) OVERRIDE {
348 delete msg;
349 return true;
350 }
351
352 void PerformTest(const ResourceResponseHead& response_head) {
353 scoped_ptr<ResourceLoaderBridge> bridge(CreateBridge());
354 bridge->Start(this);
355
356 dispatcher_->OnMessageReceived(
[email protected]f4653192013-09-06 19:24:05[diff] [blame]357 ResourceMsg_ReceivedResponse(0, response_head));
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]358 }
359
360 // ResourceLoaderBridge::Peer methods.
361 virtual void OnUploadProgress(uint64 position, uint64 size) OVERRIDE {
362 }
363
364 virtual bool OnReceivedRedirect(
365 const GURL& new_url,
366 const ResourceResponseInfo& info,
367 bool* has_new_first_party_for_cookies,
[email protected]c3e35892013-02-12 02:08:01[diff] [blame]368 GURL* new_first_party_for_cookies) OVERRIDE {
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]369 return true;
370 }
371
372 virtual void OnReceivedResponse(const ResourceResponseInfo& info) OVERRIDE {
373 response_info_ = info;
374 }
375
[email protected]ad554bc2013-09-03 21:18:47[diff] [blame]376 virtual void OnDownloadedData(int len, int encoded_data_length) OVERRIDE {
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]377 }
378
379 virtual void OnReceivedData(const char* data,
380 int data_length,
381 int encoded_data_length) OVERRIDE {
382 }
383
384 virtual void OnCompletedRequest(
[email protected]2756a8e2012-09-07 18:24:29[diff] [blame]385 int error_code,
386 bool was_ignored_by_handler,
[email protected]dcbe3df2014-02-06 23:08:37[diff] [blame^]387 bool stale_copy_in_cache,
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]388 const std::string& security_info,
389 const base::TimeTicks& completion_time) OVERRIDE {
390 }
391
392 const ResourceResponseInfo& response_info() const { return response_info_; }
393
394 private:
395 ResourceResponseInfo response_info_;
396};
397
398// TODO(simonjam): Enable this when 10829031 lands.
399TEST_F(TimeConversionTest, DISABLED_ProperlyInitialized) {
400 ResourceResponseHead response_head;
[email protected]2756a8e2012-09-07 18:24:29[diff] [blame]401 response_head.error_code = net::OK;
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]402 response_head.request_start = base::TimeTicks::FromInternalValue(5);
403 response_head.response_start = base::TimeTicks::FromInternalValue(15);
[email protected]ec298802013-03-27 16:45:07[diff] [blame]404 response_head.load_timing.request_start_time = base::Time::Now();
405 response_head.load_timing.request_start =
406 base::TimeTicks::FromInternalValue(10);
407 response_head.load_timing.connect_timing.connect_start =
408 base::TimeTicks::FromInternalValue(13);
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]409
410 PerformTest(response_head);
411
[email protected]ec298802013-03-27 16:45:07[diff] [blame]412 EXPECT_LT(base::TimeTicks(), response_info().load_timing.request_start);
413 EXPECT_EQ(base::TimeTicks(),
414 response_info().load_timing.connect_timing.dns_start);
415 EXPECT_LE(response_head.load_timing.request_start,
416 response_info().load_timing.connect_timing.connect_start);
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]417}
418
419TEST_F(TimeConversionTest, PartiallyInitialized) {
420 ResourceResponseHead response_head;
[email protected]2756a8e2012-09-07 18:24:29[diff] [blame]421 response_head.error_code = net::OK;
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]422 response_head.request_start = base::TimeTicks::FromInternalValue(5);
423 response_head.response_start = base::TimeTicks::FromInternalValue(15);
424
425 PerformTest(response_head);
426
[email protected]ec298802013-03-27 16:45:07[diff] [blame]427 EXPECT_EQ(base::TimeTicks(), response_info().load_timing.request_start);
428 EXPECT_EQ(base::TimeTicks(),
429 response_info().load_timing.connect_timing.dns_start);
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]430}
431
432TEST_F(TimeConversionTest, NotInitialized) {
433 ResourceResponseHead response_head;
[email protected]2756a8e2012-09-07 18:24:29[diff] [blame]434 response_head.error_code = net::OK;
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]435
436 PerformTest(response_head);
437
[email protected]ec298802013-03-27 16:45:07[diff] [blame]438 EXPECT_EQ(base::TimeTicks(), response_info().load_timing.request_start);
439 EXPECT_EQ(base::TimeTicks(),
440 response_info().load_timing.connect_timing.dns_start);
[email protected]04f6f982012-08-03 01:02:15[diff] [blame]441}
442
[email protected]be7b41e82012-07-04 09:46:51[diff] [blame]443} // namespace content