| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include <string> | |
| 6 #include <vector> | |
| 7 | |
| 8 #include "base/memory/scoped_ptr.h" | |
| 9 #include "base/message_loop.h" | |
| 10 #include "base/process.h" | |
| 11 #include "base/process_util.h" | |
| 12 #include "content/common/request_extra_data.h" | |
| 13 #include "content/common/resource_dispatcher.h" | |
| 14 #include "content/common/resource_messages.h" | |
| 15 #include "content/public/common/resource_response.h" | |
| 16 #include "net/base/net_errors.h" | |
| 17 #include "net/base/upload_data.h" | |
| 18 #include "net/http/http_response_headers.h" | |
| 19 #include "testing/gtest/include/gtest/gtest.h" | |
| 20 #include "webkit/common/appcache/appcache_interfaces.h" | |
| 21 | |
| 22 using webkit_glue::ResourceLoaderBridge; | |
| 23 using webkit_glue::ResourceResponseInfo; | |
| 24 | |
| 25 namespace content { | |
| 26 | |
| 27 static const char test_page_url[] = "http://www.google.com/"; | |
| 28 static const char test_page_headers[] = | |
| 29 "HTTP/1.1 200 OK\nContent-Type:text/html\n\n"; | |
| 30 static const char test_page_mime_type[] = "text/html"; | |
| 31 static const char test_page_charset[] = ""; | |
| 32 static const char test_page_contents[] = | |
| 33 "<html><head><title>Google</title></head><body><h1>Google</h1></body></html>"; | |
| 34 static const uint32 test_page_contents_len = arraysize(test_page_contents) - 1; | |
| 35 | |
| 36 static const char kShmemSegmentName[] = "DeferredResourceLoaderTest"; | |
| 37 | |
| 38 // Listens for request response data and stores it so that it can be compared | |
| 39 // to the reference data. | |
| 40 class TestRequestCallback : public ResourceLoaderBridge::Peer { | |
| 41 public: | |
| 42 TestRequestCallback() : complete_(false) { | |
| 43 } | |
| 44 | |
| 45 virtual void OnUploadProgress(uint64 position, uint64 size) OVERRIDE { | |
| 46 } | |
| 47 | |
| 48 virtual bool OnReceivedRedirect( | |
| 49 const GURL& new_url, | |
| 50 const ResourceResponseInfo& info, | |
| 51 bool* has_new_first_party_for_cookies, | |
| 52 GURL* new_first_party_for_cookies) OVERRIDE { | |
| 53 *has_new_first_party_for_cookies = false; | |
| 54 return true; | |
| 55 } | |
| 56 | |
| 57 virtual void OnReceivedResponse(const ResourceResponseInfo& info) OVERRIDE { | |
| 58 } | |
| 59 | |
| 60 virtual void OnDownloadedData(int len) OVERRIDE { | |
| 61 } | |
| 62 | |
| 63 virtual void OnReceivedData(const char* data, | |
| 64 int data_length, | |
| 65 int encoded_data_length) OVERRIDE { | |
| 66 EXPECT_FALSE(complete_); | |
| 67 data_.append(data, data_length); | |
| 68 total_encoded_data_length_ += encoded_data_length; | |
| 69 } | |
| 70 | |
| 71 virtual void OnCompletedRequest( | |
| 72 int error_code, | |
| 73 bool was_ignored_by_handler, | |
| 74 const std::string& security_info, | |
| 75 const base::TimeTicks& completion_time) OVERRIDE { | |
| 76 EXPECT_FALSE(complete_); | |
| 77 complete_ = true; | |
| 78 } | |
| 79 | |
| 80 bool complete() const { | |
| 81 return complete_; | |
| 82 } | |
| 83 const std::string& data() const { | |
| 84 return data_; | |
| 85 } | |
| 86 int total_encoded_data_length() const { | |
| 87 return total_encoded_data_length_; | |
| 88 } | |
| 89 | |
| 90 private: | |
| 91 bool complete_; | |
| 92 std::string data_; | |
| 93 int total_encoded_data_length_; | |
| 94 }; | |
| 95 | |
| 96 | |
| 97 // Sets up the message sender override for the unit test | |
| 98 class ResourceDispatcherTest : public testing::Test, public IPC::Sender { | |
| 99 public: | |
| 100 // Emulates IPC send operations (IPC::Sender) by adding | |
| 101 // pending messages to the queue. | |
| 102 virtual bool Send(IPC::Message* msg) OVERRIDE { | |
| 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()) { | |
| 112 int request_id; | |
| 113 ResourceHostMsg_Request request; | |
| 114 ASSERT_TRUE(ResourceHostMsg_RequestResource::Read( | |
| 115 &message_queue_[0], &request_id, &request)); | |
| 116 | |
| 117 // check values | |
| 118 EXPECT_EQ(test_page_url, request.url.spec()); | |
| 119 | |
| 120 // received response message | |
| 121 ResourceResponseHead response; | |
| 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; | |
| 127 dispatcher_->OnReceivedResponse(request_id, response); | |
| 128 | |
| 129 // received data message with the test contents | |
| 130 base::SharedMemory shared_mem; | |
| 131 EXPECT_TRUE(shared_mem.CreateAndMapAnonymous(test_page_contents_len)); | |
| 132 char* put_data_here = static_cast<char*>(shared_mem.memory()); | |
| 133 memcpy(put_data_here, test_page_contents, test_page_contents_len); | |
| 134 base::SharedMemoryHandle dup_handle; | |
| 135 EXPECT_TRUE(shared_mem.GiveToProcess( | |
| 136 base::Process::Current().handle(), &dup_handle)); | |
| 137 dispatcher_->OnSetDataBuffer(message_queue_[0], request_id, dup_handle, | |
| 138 test_page_contents_len, 0); | |
| 139 dispatcher_->OnReceivedData(message_queue_[0], request_id, 0, | |
| 140 test_page_contents_len, | |
| 141 test_page_contents_len); | |
| 142 | |
| 143 message_queue_.erase(message_queue_.begin()); | |
| 144 | |
| 145 // read the ack message. | |
| 146 Tuple1<int> request_ack; | |
| 147 ASSERT_TRUE(ResourceHostMsg_DataReceived_ACK::Read( | |
| 148 &message_queue_[0], &request_ack)); | |
| 149 | |
| 150 ASSERT_EQ(request_ack.a, request_id); | |
| 151 | |
| 152 message_queue_.erase(message_queue_.begin()); | |
| 153 } | |
| 154 } | |
| 155 | |
| 156 protected: | |
| 157 // testing::Test | |
| 158 virtual void SetUp() OVERRIDE { | |
| 159 dispatcher_.reset(new ResourceDispatcher(this)); | |
| 160 } | |
| 161 virtual void TearDown() OVERRIDE { | |
| 162 dispatcher_.reset(); | |
| 163 } | |
| 164 | |
| 165 ResourceLoaderBridge* CreateBridge() { | |
| 166 webkit_glue::ResourceLoaderBridge::RequestInfo request_info; | |
| 167 request_info.method = "GET"; | |
| 168 request_info.url = GURL(test_page_url); | |
| 169 request_info.first_party_for_cookies = GURL(test_page_url); | |
| 170 request_info.referrer = GURL(); | |
| 171 request_info.headers = std::string(); | |
| 172 request_info.load_flags = 0; | |
| 173 request_info.requestor_pid = 0; | |
| 174 request_info.request_type = ResourceType::SUB_RESOURCE; | |
| 175 request_info.appcache_host_id = appcache::kNoHostId; | |
| 176 request_info.routing_id = 0; | |
| 177 RequestExtraData extra_data(WebKit::WebReferrerPolicyDefault, | |
| 178 WebKit::WebString(), | |
| 179 true, 0, false, -1, true, | |
| 180 PAGE_TRANSITION_LINK, -1, -1); | |
| 181 request_info.extra_data = &extra_data; | |
| 182 | |
| 183 return dispatcher_->CreateBridge(request_info); | |
| 184 } | |
| 185 | |
| 186 std::vector<IPC::Message> message_queue_; | |
| 187 static scoped_ptr<ResourceDispatcher> dispatcher_; | |
| 188 }; | |
| 189 | |
| 190 /*static*/ | |
| 191 scoped_ptr<ResourceDispatcher> ResourceDispatcherTest::dispatcher_; | |
| 192 | |
| 193 // Does a simple request and tests that the correct data is received. | |
| 194 TEST_F(ResourceDispatcherTest, RoundTrip) { | |
| 195 TestRequestCallback callback; | |
| 196 ResourceLoaderBridge* bridge = CreateBridge(); | |
| 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()); | |
| 206 //EXPECT_EQ(test_page_contents_len, callback.total_encoded_data_length()); | |
| 207 | |
| 208 delete bridge; | |
| 209 } | |
| 210 | |
| 211 // Tests that the request IDs are straight when there are multiple requests. | |
| 212 TEST_F(ResourceDispatcherTest, MultipleRequests) { | |
| 213 // FIXME | |
| 214 } | |
| 215 | |
| 216 // Tests that the cancel method prevents other messages from being received | |
| 217 TEST_F(ResourceDispatcherTest, Cancel) { | |
| 218 // FIXME | |
| 219 } | |
| 220 | |
| 221 TEST_F(ResourceDispatcherTest, Cookies) { | |
| 222 // FIXME | |
| 223 } | |
| 224 | |
| 225 TEST_F(ResourceDispatcherTest, SerializedPostData) { | |
| 226 // FIXME | |
| 227 } | |
| 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. | |
| 234 class DeferredResourceLoadingTest : public ResourceDispatcherTest, | |
| 235 public ResourceLoaderBridge::Peer { | |
| 236 public: | |
| 237 DeferredResourceLoadingTest() | |
| 238 : defer_loading_(false) { | |
| 239 } | |
| 240 | |
| 241 virtual bool Send(IPC::Message* msg) OVERRIDE { | |
| 242 delete msg; | |
| 243 return true; | |
| 244 } | |
| 245 | |
| 246 void InitMessages() { | |
| 247 set_defer_loading(true); | |
| 248 | |
| 249 ResourceResponseHead response_head; | |
| 250 response_head.error_code = net::OK; | |
| 251 | |
| 252 dispatcher_->OnMessageReceived( | |
| 253 ResourceMsg_ReceivedResponse(0, 0, response_head)); | |
| 254 | |
| 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 | |
| 261 dispatcher_->OnMessageReceived( | |
| 262 ResourceMsg_SetDataBuffer(0, 0, duplicated_handle, 100, 0)); | |
| 263 dispatcher_->OnMessageReceived( | |
| 264 ResourceMsg_DataReceived(0, 0, 0, 100, 100)); | |
| 265 | |
| 266 set_defer_loading(false); | |
| 267 } | |
| 268 | |
| 269 // ResourceLoaderBridge::Peer methods. | |
| 270 virtual void OnUploadProgress(uint64 position, uint64 size) OVERRIDE { | |
| 271 } | |
| 272 | |
| 273 virtual bool OnReceivedRedirect( | |
| 274 const GURL& new_url, | |
| 275 const ResourceResponseInfo& info, | |
| 276 bool* has_new_first_party_for_cookies, | |
| 277 GURL* new_first_party_for_cookies) OVERRIDE { | |
| 278 *has_new_first_party_for_cookies = false; | |
| 279 return true; | |
| 280 } | |
| 281 | |
| 282 virtual void OnReceivedResponse(const ResourceResponseInfo& info) OVERRIDE { | |
| 283 EXPECT_EQ(defer_loading_, false); | |
| 284 set_defer_loading(true); | |
| 285 } | |
| 286 | |
| 287 virtual void OnDownloadedData(int len) OVERRIDE { | |
| 288 } | |
| 289 | |
| 290 virtual void OnReceivedData(const char* data, | |
| 291 int data_length, | |
| 292 int encoded_data_length) OVERRIDE { | |
| 293 EXPECT_EQ(defer_loading_, false); | |
| 294 set_defer_loading(false); | |
| 295 } | |
| 296 | |
| 297 virtual void OnCompletedRequest( | |
| 298 int error_code, | |
| 299 bool was_ignored_by_handler, | |
| 300 const std::string& security_info, | |
| 301 const base::TimeTicks& completion_time) OVERRIDE { | |
| 302 } | |
| 303 | |
| 304 protected: | |
| 305 virtual void SetUp() OVERRIDE { | |
| 306 ResourceDispatcherTest::SetUp(); | |
| 307 shared_handle_.Delete(kShmemSegmentName); | |
| 308 EXPECT_TRUE(shared_handle_.CreateNamed(kShmemSegmentName, false, 100)); | |
| 309 } | |
| 310 | |
| 311 virtual void TearDown() OVERRIDE { | |
| 312 shared_handle_.Close(); | |
| 313 EXPECT_TRUE(shared_handle_.Delete(kShmemSegmentName)); | |
| 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 | |
| 331 TEST_F(DeferredResourceLoadingTest, DeferredLoadTest) { | |
| 332 base::MessageLoop message_loop(base::MessageLoop::TYPE_IO); | |
| 333 | |
| 334 ResourceLoaderBridge* bridge = CreateBridge(); | |
| 335 | |
| 336 bridge->Start(this); | |
| 337 InitMessages(); | |
| 338 | |
| 339 // Dispatch deferred messages. | |
| 340 message_loop.RunUntilIdle(); | |
| 341 delete bridge; | |
| 342 } | |
| 343 | |
| 344 class 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( | |
| 357 ResourceMsg_ReceivedResponse(0, 0, response_head)); | |
| 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, | |
| 368 GURL* new_first_party_for_cookies) OVERRIDE { | |
| 369 return true; | |
| 370 } | |
| 371 | |
| 372 virtual void OnReceivedResponse(const ResourceResponseInfo& info) OVERRIDE { | |
| 373 response_info_ = info; | |
| 374 } | |
| 375 | |
| 376 virtual void OnDownloadedData(int len) OVERRIDE { | |
| 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( | |
| 385 int error_code, | |
| 386 bool was_ignored_by_handler, | |
| 387 const std::string& security_info, | |
| 388 const base::TimeTicks& completion_time) OVERRIDE { | |
| 389 } | |
| 390 | |
| 391 const ResourceResponseInfo& response_info() const { return response_info_; } | |
| 392 | |
| 393 private: | |
| 394 ResourceResponseInfo response_info_; | |
| 395 }; | |
| 396 | |
| 397 // TODO(simonjam): Enable this when 10829031 lands. | |
| 398 TEST_F(TimeConversionTest, DISABLED_ProperlyInitialized) { | |
| 399 ResourceResponseHead response_head; | |
| 400 response_head.error_code = net::OK; | |
| 401 response_head.request_start = base::TimeTicks::FromInternalValue(5); | |
| 402 response_head.response_start = base::TimeTicks::FromInternalValue(15); | |
| 403 response_head.load_timing.request_start_time = base::Time::Now(); | |
| 404 response_head.load_timing.request_start = | |
| 405 base::TimeTicks::FromInternalValue(10); | |
| 406 response_head.load_timing.connect_timing.connect_start = | |
| 407 base::TimeTicks::FromInternalValue(13); | |
| 408 | |
| 409 PerformTest(response_head); | |
| 410 | |
| 411 EXPECT_LT(base::TimeTicks(), response_info().load_timing.request_start); | |
| 412 EXPECT_EQ(base::TimeTicks(), | |
| 413 response_info().load_timing.connect_timing.dns_start); | |
| 414 EXPECT_LE(response_head.load_timing.request_start, | |
| 415 response_info().load_timing.connect_timing.connect_start); | |
| 416 } | |
| 417 | |
| 418 TEST_F(TimeConversionTest, PartiallyInitialized) { | |
| 419 ResourceResponseHead response_head; | |
| 420 response_head.error_code = net::OK; | |
| 421 response_head.request_start = base::TimeTicks::FromInternalValue(5); | |
| 422 response_head.response_start = base::TimeTicks::FromInternalValue(15); | |
| 423 | |
| 424 PerformTest(response_head); | |
| 425 | |
| 426 EXPECT_EQ(base::TimeTicks(), response_info().load_timing.request_start); | |
| 427 EXPECT_EQ(base::TimeTicks(), | |
| 428 response_info().load_timing.connect_timing.dns_start); | |
| 429 } | |
| 430 | |
| 431 TEST_F(TimeConversionTest, NotInitialized) { | |
| 432 ResourceResponseHead response_head; | |
| 433 response_head.error_code = net::OK; | |
| 434 | |
| 435 PerformTest(response_head); | |
| 436 | |
| 437 EXPECT_EQ(base::TimeTicks(), response_info().load_timing.request_start); | |
| 438 EXPECT_EQ(base::TimeTicks(), | |
| 439 response_info().load_timing.connect_timing.dns_start); | |
| 440 } | |
| 441 | |
| 442 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 16328003:
Move a bunch of child-only code from content/common to content/child (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src