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 <stack> 6 #include <string> 7 #include <vector> 8 9 #include "base/bind.h" 10 #include "base/bind_helpers.h" 11 #include "base/callback.h" 12 #include "base/message_loop/message_loop.h" 13 #include "base/synchronization/waitable_event.h" 14 #include "base/threading/thread.h" 15 #include "net/base/net_errors.h" 16 #include "net/http/http_response_headers.h" 17 #include "net/url_request/url_request.h" 18 #include "net/url_request/url_request_context.h" 19 #include "net/url_request/url_request_error_job.h" 20 #include "testing/gtest/include/gtest/gtest.h" 21 #include "webkit/browser/appcache/appcache.h" 22 #include "webkit/browser/appcache/appcache_backend_impl.h" 23 #include "webkit/browser/appcache/appcache_request_handler.h" 24 #include "webkit/browser/appcache/appcache_url_request_job.h" 25 #include "webkit/browser/appcache/mock_appcache_policy.h" 26 #include "webkit/browser/appcache/mock_appcache_service.h" 27 28 namespace appcache { 29 30 static const int kMockProcessId = 1; 31 32 class AppCacheRequestHandlerTest : public testing::Test { 33 public: 34 class MockFrontend : public AppCacheFrontend { 35 public: 36 virtual void OnCacheSelected( 37 int host_id, const appcache::AppCacheInfo& info) OVERRIDE {} 38 39 virtual void OnStatusChanged(const std::vector<int>& host_ids, 40 appcache::Status status) OVERRIDE {} 41 42 virtual void OnEventRaised(const std::vector<int>& host_ids, 43 appcache::EventID event_id) OVERRIDE {} 44 45 virtual void OnErrorEventRaised(const std::vector<int>& host_ids, 46 const std::string& message) OVERRIDE {} 47 48 virtual void OnProgressEventRaised(const std::vector<int>& host_ids, 49 const GURL& url, 50 int num_total, 51 int num_complete) OVERRIDE { 52 } 53 54 virtual void OnLogMessage(int host_id, 55 appcache::LogLevel log_level, 56 const std::string& message) OVERRIDE { 57 } 58 59 virtual void OnContentBlocked(int host_id, 60 const GURL& manifest_url) OVERRIDE {} 61 }; 62 63 // Helper callback to run a test on our io_thread. The io_thread is spun up 64 // once and reused for all tests. 65 template <class Method> 66 void MethodWrapper(Method method) { 67 SetUpTest(); 68 (this->*method)(); 69 } 70 71 // Subclasses to simulate particular responses so test cases can 72 // exercise fallback code paths. 73 74 class MockURLRequestDelegate : public net::URLRequest::Delegate { 75 virtual void OnResponseStarted(net::URLRequest* request) OVERRIDE {} 76 virtual void OnReadCompleted(net::URLRequest* request, 77 int bytes_read) OVERRIDE { 78 } 79 }; 80 81 class MockURLRequestJob : public net::URLRequestJob { 82 public: 83 MockURLRequestJob(net::URLRequest* request, 84 net::NetworkDelegate* network_delegate, 85 int response_code) 86 : net::URLRequestJob(request, network_delegate), 87 response_code_(response_code), 88 has_response_info_(false) {} 89 MockURLRequestJob(net::URLRequest* request, 90 net::NetworkDelegate* network_delegate, 91 const net::HttpResponseInfo& info) 92 : net::URLRequestJob(request, network_delegate), 93 response_code_(info.headers->response_code()), 94 has_response_info_(true), 95 response_info_(info) {} 96 97 protected: 98 virtual ~MockURLRequestJob() {} 99 virtual void Start() OVERRIDE { 100 NotifyHeadersComplete(); 101 } 102 virtual int GetResponseCode() const OVERRIDE { 103 return response_code_; 104 } 105 virtual void GetResponseInfo( 106 net::HttpResponseInfo* info) OVERRIDE { 107 if (!has_response_info_) 108 return; 109 *info = response_info_; 110 } 111 112 private: 113 int response_code_; 114 bool has_response_info_; 115 net::HttpResponseInfo response_info_; 116 }; 117 118 class MockURLRequest : public net::URLRequest { 119 public: 120 MockURLRequest( 121 const GURL& url, 122 net::URLRequestContext* context, 123 net::NetworkDelegate* network_delegate) : 124 net::URLRequest(url, NULL, context, network_delegate), 125 network_delegate_(network_delegate) { 126 } 127 128 void SimulateResponseCode(int http_response_code) { 129 mock_factory_job_ = new MockURLRequestJob( 130 this, network_delegate_, http_response_code); 131 Start(); 132 DCHECK(!mock_factory_job_); 133 // All our simulation needs to satisfy are the following two DCHECKs 134 DCHECK(status().is_success()); 135 DCHECK_EQ(http_response_code, GetResponseCode()); 136 } 137 138 void SimulateResponseInfo(const net::HttpResponseInfo& info) { 139 mock_factory_job_ = new MockURLRequestJob( 140 this, network_delegate_, info); 141 set_delegate(&delegate_); // needed to get the info back out 142 Start(); 143 DCHECK(!mock_factory_job_); 144 } 145 146 MockURLRequestDelegate delegate_; 147 148 private: 149 net::NetworkDelegate* network_delegate_; 150 }; 151 152 static net::URLRequestJob* MockHttpJobFactory( 153 net::URLRequest* request, 154 net::NetworkDelegate* network_delegate, 155 const std::string& scheme) { 156 if (mock_factory_job_) { 157 net::URLRequestJob* temp = mock_factory_job_; 158 mock_factory_job_ = NULL; 159 return temp; 160 } else { 161 // Some of these tests trigger UpdateJobs which start URLRequests. 162 // We short circuit those be returning error jobs. 163 return new net::URLRequestErrorJob(request, 164 network_delegate, 165 net::ERR_INTERNET_DISCONNECTED); 166 } 167 } 168 169 static void SetUpTestCase() { 170 io_thread_.reset(new base::Thread("AppCacheRequestHandlerTest Thread")); 171 base::Thread::Options options(base::MessageLoop::TYPE_IO, 0); 172 io_thread_->StartWithOptions(options); 173 } 174 175 static void TearDownTestCase() { 176 io_thread_.reset(NULL); 177 } 178 179 // Test harness -------------------------------------------------- 180 181 AppCacheRequestHandlerTest() 182 : host_(NULL), empty_network_delegate_(NULL), orig_http_factory_(NULL) { 183 } 184 185 template <class Method> 186 void RunTestOnIOThread(Method method) { 187 test_finished_event_ .reset(new base::WaitableEvent(false, false)); 188 io_thread_->message_loop()->PostTask( 189 FROM_HERE, 190 base::Bind(&AppCacheRequestHandlerTest::MethodWrapper<Method>, 191 base::Unretained(this), method)); 192 test_finished_event_->Wait(); 193 } 194 195 void SetUpTest() { 196 DCHECK(base::MessageLoop::current() == io_thread_->message_loop()); 197 orig_http_factory_ = net::URLRequest::Deprecated::RegisterProtocolFactory( 198 "http", MockHttpJobFactory); 199 mock_service_.reset(new MockAppCacheService); 200 mock_service_->set_request_context(&empty_context_); 201 mock_policy_.reset(new MockAppCachePolicy); 202 mock_service_->set_appcache_policy(mock_policy_.get()); 203 mock_frontend_.reset(new MockFrontend); 204 backend_impl_.reset(new AppCacheBackendImpl); 205 backend_impl_->Initialize(mock_service_.get(), mock_frontend_.get(), 206 kMockProcessId); 207 const int kHostId = 1; 208 backend_impl_->RegisterHost(kHostId); 209 host_ = backend_impl_->GetHost(kHostId); 210 empty_network_delegate_ = NULL; 211 } 212 213 void TearDownTest() { 214 DCHECK(base::MessageLoop::current() == io_thread_->message_loop()); 215 DCHECK(!mock_factory_job_); 216 net::URLRequest::Deprecated::RegisterProtocolFactory( 217 "http", orig_http_factory_); 218 orig_http_factory_ = NULL; 219 job_ = NULL; 220 handler_.reset(); 221 request_.reset(); 222 backend_impl_.reset(); 223 mock_frontend_.reset(); 224 mock_service_.reset(); 225 mock_policy_.reset(); 226 host_ = NULL; 227 empty_network_delegate_ = NULL; 228 } 229 230 void TestFinished() { 231 // We unwind the stack prior to finishing up to let stack 232 // based objects get deleted. 233 DCHECK(base::MessageLoop::current() == io_thread_->message_loop()); 234 base::MessageLoop::current()->PostTask( 235 FROM_HERE, 236 base::Bind(&AppCacheRequestHandlerTest::TestFinishedUnwound, 237 base::Unretained(this))); 238 } 239 240 void TestFinishedUnwound() { 241 TearDownTest(); 242 test_finished_event_->Signal(); 243 } 244 245 void PushNextTask(const base::Closure& task) { 246 task_stack_.push(task); 247 } 248 249 void ScheduleNextTask() { 250 DCHECK(base::MessageLoop::current() == io_thread_->message_loop()); 251 if (task_stack_.empty()) { 252 TestFinished(); 253 return; 254 } 255 base::MessageLoop::current()->PostTask(FROM_HERE, task_stack_.top()); 256 task_stack_.pop(); 257 } 258 259 // MainResource_Miss -------------------------------------------------- 260 261 void MainResource_Miss() { 262 PushNextTask( 263 base::Bind(&AppCacheRequestHandlerTest::Verify_MainResource_Miss, 264 base::Unretained(this))); 265 266 request_.reset(new MockURLRequest( 267 GURL("http://blah/"), &empty_context_, empty_network_delegate_)); 268 handler_.reset(host_->CreateRequestHandler(request_.get(), 269 ResourceType::MAIN_FRAME)); 270 EXPECT_TRUE(handler_.get()); 271 272 job_ = handler_->MaybeLoadResource(request_.get(), empty_network_delegate_); 273 EXPECT_TRUE(job_.get()); 274 EXPECT_TRUE(job_->is_waiting()); 275 276 // We have to wait for completion of storage->FindResponseForMainRequest. 277 ScheduleNextTask(); 278 } 279 280 void Verify_MainResource_Miss() { 281 EXPECT_FALSE(job_->is_waiting()); 282 EXPECT_TRUE(job_->is_delivering_network_response()); 283 284 int64 cache_id = kNoCacheId; 285 GURL manifest_url; 286 handler_->GetExtraResponseInfo(&cache_id, &manifest_url); 287 EXPECT_EQ(kNoCacheId, cache_id); 288 EXPECT_EQ(GURL(), manifest_url); 289 EXPECT_EQ(0, handler_->found_group_id_); 290 291 AppCacheURLRequestJob* fallback_job; 292 fallback_job = handler_->MaybeLoadFallbackForRedirect( 293 request_.get(), 294 empty_network_delegate_, 295 GURL("http://blah/redirect")); 296 EXPECT_FALSE(fallback_job); 297 fallback_job = handler_->MaybeLoadFallbackForResponse( 298 request_.get(), empty_network_delegate_); 299 EXPECT_FALSE(fallback_job); 300 301 EXPECT_TRUE(host_->preferred_manifest_url().is_empty()); 302 303 TestFinished(); 304 } 305 306 // MainResource_Hit -------------------------------------------------- 307 308 void MainResource_Hit() { 309 PushNextTask( 310 base::Bind(&AppCacheRequestHandlerTest::Verify_MainResource_Hit, 311 base::Unretained(this))); 312 313 request_.reset(new MockURLRequest( 314 GURL("http://blah/"), &empty_context_, empty_network_delegate_)); 315 handler_.reset(host_->CreateRequestHandler(request_.get(), 316 ResourceType::MAIN_FRAME)); 317 EXPECT_TRUE(handler_.get()); 318 319 mock_storage()->SimulateFindMainResource( 320 AppCacheEntry(AppCacheEntry::EXPLICIT, 1), 321 GURL(), AppCacheEntry(), 322 1, 2, GURL("http://blah/manifest/")); 323 324 job_ = handler_->MaybeLoadResource(request_.get(), empty_network_delegate_); 325 EXPECT_TRUE(job_.get()); 326 EXPECT_TRUE(job_->is_waiting()); 327 328 // We have to wait for completion of storage->FindResponseForMainRequest. 329 ScheduleNextTask(); 330 } 331 332 void Verify_MainResource_Hit() { 333 EXPECT_FALSE(job_->is_waiting()); 334 EXPECT_TRUE(job_->is_delivering_appcache_response()); 335 336 int64 cache_id = kNoCacheId; 337 GURL manifest_url; 338 handler_->GetExtraResponseInfo(&cache_id, &manifest_url); 339 EXPECT_EQ(1, cache_id); 340 EXPECT_EQ(GURL("http://blah/manifest/"), manifest_url); 341 EXPECT_EQ(2, handler_->found_group_id_); 342 343 AppCacheURLRequestJob* fallback_job; 344 fallback_job = handler_->MaybeLoadFallbackForResponse( 345 request_.get(), empty_network_delegate_); 346 EXPECT_FALSE(fallback_job); 347 348 EXPECT_EQ(GURL("http://blah/manifest/"), 349 host_->preferred_manifest_url()); 350 351 TestFinished(); 352 } 353 354 // MainResource_Fallback -------------------------------------------------- 355 356 void MainResource_Fallback() { 357 PushNextTask( 358 base::Bind(&AppCacheRequestHandlerTest::Verify_MainResource_Fallback, 359 base::Unretained(this))); 360 361 request_.reset(new MockURLRequest( 362 GURL("http://blah/"), &empty_context_, empty_network_delegate_)); 363 handler_.reset(host_->CreateRequestHandler(request_.get(), 364 ResourceType::MAIN_FRAME)); 365 EXPECT_TRUE(handler_.get()); 366 367 mock_storage()->SimulateFindMainResource( 368 AppCacheEntry(), 369 GURL("http://blah/fallbackurl"), 370 AppCacheEntry(AppCacheEntry::EXPLICIT, 1), 371 1, 2, GURL("http://blah/manifest/")); 372 373 job_ = handler_->MaybeLoadResource(request_.get(), empty_network_delegate_); 374 EXPECT_TRUE(job_.get()); 375 EXPECT_TRUE(job_->is_waiting()); 376 377 // We have to wait for completion of storage->FindResponseForMainRequest. 378 ScheduleNextTask(); 379 } 380 381 void Verify_MainResource_Fallback() { 382 EXPECT_FALSE(job_->is_waiting()); 383 EXPECT_TRUE(job_->is_delivering_network_response()); 384 385 // When the request is restarted, the existing job is dropped so a 386 // real network job gets created. We expect NULL here which will cause 387 // the net library to create a real job. 388 job_ = handler_->MaybeLoadResource(request_.get(), empty_network_delegate_); 389 EXPECT_FALSE(job_.get()); 390 391 // Simulate an http error of the real network job. 392 request_->SimulateResponseCode(500); 393 394 job_ = handler_->MaybeLoadFallbackForResponse( 395 request_.get(), empty_network_delegate_); 396 EXPECT_TRUE(job_.get()); 397 EXPECT_TRUE(job_->is_delivering_appcache_response()); 398 399 int64 cache_id = kNoCacheId; 400 GURL manifest_url; 401 handler_->GetExtraResponseInfo(&cache_id, &manifest_url); 402 EXPECT_EQ(1, cache_id); 403 EXPECT_EQ(GURL("http://blah/manifest/"), manifest_url); 404 EXPECT_TRUE(host_->main_resource_was_namespace_entry_); 405 EXPECT_EQ(GURL("http://blah/fallbackurl"), host_->namespace_entry_url_); 406 407 EXPECT_EQ(GURL("http://blah/manifest/"), 408 host_->preferred_manifest_url()); 409 410 TestFinished(); 411 } 412 413 // MainResource_FallbackOverride -------------------------------------------- 414 415 void MainResource_FallbackOverride() { 416 PushNextTask(base::Bind( 417 &AppCacheRequestHandlerTest::Verify_MainResource_FallbackOverride, 418 base::Unretained(this))); 419 420 request_.reset(new MockURLRequest( 421 GURL("http://blah/fallback-override"), 422 &empty_context_, empty_network_delegate_)); 423 handler_.reset(host_->CreateRequestHandler(request_.get(), 424 ResourceType::MAIN_FRAME)); 425 EXPECT_TRUE(handler_.get()); 426 427 mock_storage()->SimulateFindMainResource( 428 AppCacheEntry(), 429 GURL("http://blah/fallbackurl"), 430 AppCacheEntry(AppCacheEntry::EXPLICIT, 1), 431 1, 2, GURL("http://blah/manifest/")); 432 433 job_ = handler_->MaybeLoadResource(request_.get(), empty_network_delegate_); 434 EXPECT_TRUE(job_.get()); 435 EXPECT_TRUE(job_->is_waiting()); 436 437 // We have to wait for completion of storage->FindResponseForMainRequest. 438 ScheduleNextTask(); 439 } 440 441 void Verify_MainResource_FallbackOverride() { 442 EXPECT_FALSE(job_->is_waiting()); 443 EXPECT_TRUE(job_->is_delivering_network_response()); 444 445 // When the request is restarted, the existing job is dropped so a 446 // real network job gets created. We expect NULL here which will cause 447 // the net library to create a real job. 448 job_ = handler_->MaybeLoadResource(request_.get(), empty_network_delegate_); 449 EXPECT_FALSE(job_.get()); 450 451 // Simulate an http error of the real network job, but with custom 452 // headers that override the fallback behavior. 453 const char kOverrideHeaders[] = 454 "HTTP/1.1 404 BOO HOO\0" 455 "x-chromium-appcache-fallback-override: disallow-fallback\0" 456 "\0"; 457 net::HttpResponseInfo info; 458 info.headers = new net::HttpResponseHeaders( 459 std::string(kOverrideHeaders, arraysize(kOverrideHeaders))); 460 request_->SimulateResponseInfo(info); 461 462 job_ = handler_->MaybeLoadFallbackForResponse( 463 request_.get(), empty_network_delegate_); 464 EXPECT_FALSE(job_.get()); 465 466 TestFinished(); 467 } 468 469 // SubResource_Miss_WithNoCacheSelected ---------------------------------- 470 471 void SubResource_Miss_WithNoCacheSelected() { 472 request_.reset(new MockURLRequest( 473 GURL("http://blah/"), &empty_context_, empty_network_delegate_)); 474 handler_.reset(host_->CreateRequestHandler(request_.get(), 475 ResourceType::SUB_RESOURCE)); 476 477 // We avoid creating handler when possible, sub-resource requests are not 478 // subject to retrieval from an appcache when there's no associated cache. 479 EXPECT_FALSE(handler_.get()); 480 481 TestFinished(); 482 } 483 484 // SubResource_Miss_WithCacheSelected ---------------------------------- 485 486 void SubResource_Miss_WithCacheSelected() { 487 // A sub-resource load where the resource is not in an appcache, or 488 // in a network or fallback namespace, should result in a failed request. 489 host_->AssociateCompleteCache(MakeNewCache()); 490 491 request_.reset(new MockURLRequest( 492 GURL("http://blah/"), &empty_context_, empty_network_delegate_)); 493 handler_.reset(host_->CreateRequestHandler(request_.get(), 494 ResourceType::SUB_RESOURCE)); 495 EXPECT_TRUE(handler_.get()); 496 497 job_ = handler_->MaybeLoadResource(request_.get(), empty_network_delegate_); 498 EXPECT_TRUE(job_.get()); 499 EXPECT_TRUE(job_->is_delivering_error_response()); 500 501 AppCacheURLRequestJob* fallback_job; 502 fallback_job = handler_->MaybeLoadFallbackForRedirect( 503 request_.get(), empty_network_delegate_, GURL("http://blah/redirect")); 504 EXPECT_FALSE(fallback_job); 505 fallback_job = handler_->MaybeLoadFallbackForResponse( 506 request_.get(), empty_network_delegate_); 507 EXPECT_FALSE(fallback_job); 508 509 TestFinished(); 510 } 511 512 // SubResource_Miss_WithWaitForCacheSelection ----------------------------- 513 514 void SubResource_Miss_WithWaitForCacheSelection() { 515 // Precondition, the host is waiting on cache selection. 516 scoped_refptr<AppCache> cache(MakeNewCache()); 517 host_->pending_selected_cache_id_ = cache->cache_id(); 518 host_->set_preferred_manifest_url(cache->owning_group()->manifest_url()); 519 520 request_.reset(new MockURLRequest( 521 GURL("http://blah/"), &empty_context_, empty_network_delegate_)); 522 handler_.reset(host_->CreateRequestHandler(request_.get(), 523 ResourceType::SUB_RESOURCE)); 524 EXPECT_TRUE(handler_.get()); 525 job_ = handler_->MaybeLoadResource(request_.get(), empty_network_delegate_); 526 EXPECT_TRUE(job_.get()); 527 EXPECT_TRUE(job_->is_waiting()); 528 529 host_->FinishCacheSelection(cache.get(), NULL); 530 EXPECT_FALSE(job_->is_waiting()); 531 EXPECT_TRUE(job_->is_delivering_error_response()); 532 533 AppCacheURLRequestJob* fallback_job; 534 fallback_job = handler_->MaybeLoadFallbackForRedirect( 535 request_.get(), empty_network_delegate_, GURL("http://blah/redirect")); 536 EXPECT_FALSE(fallback_job); 537 fallback_job = handler_->MaybeLoadFallbackForResponse( 538 request_.get(), empty_network_delegate_); 539 EXPECT_FALSE(fallback_job); 540 541 TestFinished(); 542 } 543 544 // SubResource_Hit ----------------------------- 545 546 void SubResource_Hit() { 547 host_->AssociateCompleteCache(MakeNewCache()); 548 549 mock_storage()->SimulateFindSubResource( 550 AppCacheEntry(AppCacheEntry::EXPLICIT, 1), AppCacheEntry(), false); 551 552 request_.reset(new MockURLRequest( 553 GURL("http://blah/"), &empty_context_, empty_network_delegate_)); 554 handler_.reset(host_->CreateRequestHandler(request_.get(), 555 ResourceType::SUB_RESOURCE)); 556 EXPECT_TRUE(handler_.get()); 557 job_ = handler_->MaybeLoadResource(request_.get(), empty_network_delegate_); 558 EXPECT_TRUE(job_.get()); 559 EXPECT_TRUE(job_->is_delivering_appcache_response()); 560 561 AppCacheURLRequestJob* fallback_job; 562 fallback_job = handler_->MaybeLoadFallbackForRedirect( 563 request_.get(), empty_network_delegate_, GURL("http://blah/redirect")); 564 EXPECT_FALSE(fallback_job); 565 fallback_job = handler_->MaybeLoadFallbackForResponse( 566 request_.get(), empty_network_delegate_); 567 EXPECT_FALSE(fallback_job); 568 569 TestFinished(); 570 } 571 572 // SubResource_RedirectFallback ----------------------------- 573 574 void SubResource_RedirectFallback() { 575 // Redirects to resources in the a different origin are subject to 576 // fallback namespaces. 577 host_->AssociateCompleteCache(MakeNewCache()); 578 579 mock_storage()->SimulateFindSubResource( 580 AppCacheEntry(), AppCacheEntry(AppCacheEntry::EXPLICIT, 1), false); 581 582 request_.reset(new MockURLRequest( 583 GURL("http://blah/"), &empty_context_, empty_network_delegate_)); 584 handler_.reset(host_->CreateRequestHandler(request_.get(), 585 ResourceType::SUB_RESOURCE)); 586 EXPECT_TRUE(handler_.get()); 587 job_ = handler_->MaybeLoadResource(request_.get(), empty_network_delegate_); 588 EXPECT_FALSE(job_.get()); 589 590 job_ = handler_->MaybeLoadFallbackForRedirect( 591 request_.get(), 592 empty_network_delegate_, 593 GURL("http://not_blah/redirect")); 594 EXPECT_TRUE(job_.get()); 595 EXPECT_TRUE(job_->is_delivering_appcache_response()); 596 597 AppCacheURLRequestJob* fallback_job; 598 fallback_job = handler_->MaybeLoadFallbackForResponse( 599 request_.get(), empty_network_delegate_); 600 EXPECT_FALSE(fallback_job); 601 602 TestFinished(); 603 } 604 605 // SubResource_NoRedirectFallback ----------------------------- 606 607 void SubResource_NoRedirectFallback() { 608 // Redirects to resources in the same-origin are not subject to 609 // fallback namespaces. 610 host_->AssociateCompleteCache(MakeNewCache()); 611 612 mock_storage()->SimulateFindSubResource( 613 AppCacheEntry(), AppCacheEntry(AppCacheEntry::EXPLICIT, 1), false); 614 615 request_.reset(new MockURLRequest( 616 GURL("http://blah/"), &empty_context_, empty_network_delegate_)); 617 handler_.reset(host_->CreateRequestHandler(request_.get(), 618 ResourceType::SUB_RESOURCE)); 619 EXPECT_TRUE(handler_.get()); 620 job_ = handler_->MaybeLoadResource(request_.get(), empty_network_delegate_); 621 EXPECT_FALSE(job_.get()); 622 623 AppCacheURLRequestJob* fallback_job; 624 fallback_job = handler_->MaybeLoadFallbackForRedirect( 625 request_.get(), empty_network_delegate_, GURL("http://blah/redirect")); 626 EXPECT_FALSE(fallback_job); 627 628 request_->SimulateResponseCode(200); 629 fallback_job = handler_->MaybeLoadFallbackForResponse( 630 request_.get(), empty_network_delegate_); 631 EXPECT_FALSE(fallback_job); 632 633 TestFinished(); 634 } 635 636 // SubResource_Network ----------------------------- 637 638 void SubResource_Network() { 639 // A sub-resource load where the resource is in a network namespace, 640 // should result in the system using a 'real' job to do the network 641 // retrieval. 642 host_->AssociateCompleteCache(MakeNewCache()); 643 644 mock_storage()->SimulateFindSubResource( 645 AppCacheEntry(), AppCacheEntry(), true); 646 647 request_.reset(new MockURLRequest( 648 GURL("http://blah/"), &empty_context_, empty_network_delegate_)); 649 handler_.reset(host_->CreateRequestHandler(request_.get(), 650 ResourceType::SUB_RESOURCE)); 651 EXPECT_TRUE(handler_.get()); 652 job_ = handler_->MaybeLoadResource(request_.get(), empty_network_delegate_); 653 EXPECT_FALSE(job_.get()); 654 655 AppCacheURLRequestJob* fallback_job; 656 fallback_job = handler_->MaybeLoadFallbackForRedirect( 657 request_.get(), empty_network_delegate_, GURL("http://blah/redirect")); 658 EXPECT_FALSE(fallback_job); 659 fallback_job = handler_->MaybeLoadFallbackForResponse( 660 request_.get(), empty_network_delegate_); 661 EXPECT_FALSE(fallback_job); 662 663 TestFinished(); 664 } 665 666 // DestroyedHost ----------------------------- 667 668 void DestroyedHost() { 669 host_->AssociateCompleteCache(MakeNewCache()); 670 671 mock_storage()->SimulateFindSubResource( 672 AppCacheEntry(AppCacheEntry::EXPLICIT, 1), AppCacheEntry(), false); 673 674 request_.reset(new MockURLRequest( 675 GURL("http://blah/"), &empty_context_, empty_network_delegate_)); 676 handler_.reset(host_->CreateRequestHandler(request_.get(), 677 ResourceType::SUB_RESOURCE)); 678 EXPECT_TRUE(handler_.get()); 679 680 backend_impl_->UnregisterHost(1); 681 host_ = NULL; 682 683 EXPECT_FALSE(handler_->MaybeLoadResource( 684 request_.get(), empty_network_delegate_)); 685 EXPECT_FALSE(handler_->MaybeLoadFallbackForRedirect( 686 request_.get(), empty_network_delegate_, GURL("http://blah/redirect"))); 687 EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse( 688 request_.get(), empty_network_delegate_)); 689 690 TestFinished(); 691 } 692 693 // DestroyedHostWithWaitingJob ----------------------------- 694 695 void DestroyedHostWithWaitingJob() { 696 // Precondition, the host is waiting on cache selection. 697 host_->pending_selected_cache_id_ = 1; 698 699 request_.reset(new MockURLRequest( 700 GURL("http://blah/"), &empty_context_, empty_network_delegate_)); 701 handler_.reset(host_->CreateRequestHandler(request_.get(), 702 ResourceType::SUB_RESOURCE)); 703 EXPECT_TRUE(handler_.get()); 704 705 job_ = handler_->MaybeLoadResource(request_.get(), empty_network_delegate_); 706 EXPECT_TRUE(job_.get()); 707 EXPECT_TRUE(job_->is_waiting()); 708 709 backend_impl_->UnregisterHost(1); 710 host_ = NULL; 711 EXPECT_TRUE(job_->has_been_killed()); 712 713 EXPECT_FALSE(handler_->MaybeLoadResource( 714 request_.get(), empty_network_delegate_)); 715 EXPECT_FALSE(handler_->MaybeLoadFallbackForRedirect( 716 request_.get(), empty_network_delegate_, GURL("http://blah/redirect"))); 717 EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse( 718 request_.get(), empty_network_delegate_)); 719 720 TestFinished(); 721 } 722 723 // UnsupportedScheme ----------------------------- 724 725 void UnsupportedScheme() { 726 // Precondition, the host is waiting on cache selection. 727 host_->pending_selected_cache_id_ = 1; 728 729 request_.reset(new MockURLRequest( 730 GURL("ftp://blah/"), &empty_context_, empty_network_delegate_)); 731 handler_.reset(host_->CreateRequestHandler(request_.get(), 732 ResourceType::SUB_RESOURCE)); 733 EXPECT_TRUE(handler_.get()); // we could redirect to http (conceivably) 734 735 EXPECT_FALSE(handler_->MaybeLoadResource( 736 request_.get(), empty_network_delegate_)); 737 EXPECT_FALSE(handler_->MaybeLoadFallbackForRedirect( 738 request_.get(), empty_network_delegate_, GURL("ftp://blah/redirect"))); 739 EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse( 740 request_.get(), empty_network_delegate_)); 741 742 TestFinished(); 743 } 744 745 // CanceledRequest ----------------------------- 746 747 void CanceledRequest() { 748 request_.reset(new MockURLRequest( 749 GURL("http://blah/"), &empty_context_, empty_network_delegate_)); 750 handler_.reset(host_->CreateRequestHandler(request_.get(), 751 ResourceType::MAIN_FRAME)); 752 EXPECT_TRUE(handler_.get()); 753 754 job_ = handler_->MaybeLoadResource(request_.get(), empty_network_delegate_); 755 EXPECT_TRUE(job_.get()); 756 EXPECT_TRUE(job_->is_waiting()); 757 EXPECT_FALSE(job_->has_been_started()); 758 759 mock_factory_job_ = job_.get(); 760 request_->Start(); 761 EXPECT_TRUE(job_->has_been_started()); 762 763 request_->Cancel(); 764 EXPECT_TRUE(job_->has_been_killed()); 765 766 EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse( 767 request_.get(), empty_network_delegate_)); 768 769 TestFinished(); 770 } 771 772 // WorkerRequest ----------------------------- 773 774 void WorkerRequest() { 775 EXPECT_TRUE(AppCacheRequestHandler::IsMainResourceType( 776 ResourceType::MAIN_FRAME)); 777 EXPECT_TRUE(AppCacheRequestHandler::IsMainResourceType( 778 ResourceType::SUB_FRAME)); 779 EXPECT_TRUE(AppCacheRequestHandler::IsMainResourceType( 780 ResourceType::SHARED_WORKER)); 781 EXPECT_FALSE(AppCacheRequestHandler::IsMainResourceType( 782 ResourceType::WORKER)); 783 784 request_.reset(new MockURLRequest( 785 GURL("http://blah/"), &empty_context_, empty_network_delegate_)); 786 787 const int kParentHostId = host_->host_id(); 788 const int kWorkerHostId = 2; 789 const int kAbandonedWorkerHostId = 3; 790 const int kNonExsitingHostId = 700; 791 792 backend_impl_->RegisterHost(kWorkerHostId); 793 AppCacheHost* worker_host = backend_impl_->GetHost(kWorkerHostId); 794 worker_host->SelectCacheForWorker(kParentHostId, kMockProcessId); 795 handler_.reset(worker_host->CreateRequestHandler( 796 request_.get(), ResourceType::SHARED_WORKER)); 797 EXPECT_TRUE(handler_.get()); 798 // Verify that the handler is associated with the parent host. 799 EXPECT_EQ(host_, handler_->host_); 800 801 // Create a new worker host, but associate it with a parent host that 802 // does not exists to simulate the host having been torn down. 803 backend_impl_->UnregisterHost(kWorkerHostId); 804 backend_impl_->RegisterHost(kAbandonedWorkerHostId); 805 worker_host = backend_impl_->GetHost(kAbandonedWorkerHostId); 806 EXPECT_EQ(NULL, backend_impl_->GetHost(kNonExsitingHostId)); 807 worker_host->SelectCacheForWorker(kNonExsitingHostId, kMockProcessId); 808 handler_.reset(worker_host->CreateRequestHandler( 809 request_.get(), ResourceType::SHARED_WORKER)); 810 EXPECT_FALSE(handler_.get()); 811 812 TestFinished(); 813 } 814 815 // MainResource_Blocked -------------------------------------------------- 816 817 void MainResource_Blocked() { 818 PushNextTask( 819 base::Bind(&AppCacheRequestHandlerTest::Verify_MainResource_Blocked, 820 base::Unretained(this))); 821 822 request_.reset(new MockURLRequest( 823 GURL("http://blah/"), &empty_context_, empty_network_delegate_)); 824 handler_.reset(host_->CreateRequestHandler(request_.get(), 825 ResourceType::MAIN_FRAME)); 826 EXPECT_TRUE(handler_.get()); 827 828 mock_policy_->can_load_return_value_ = false; 829 mock_storage()->SimulateFindMainResource( 830 AppCacheEntry(AppCacheEntry::EXPLICIT, 1), 831 GURL(), AppCacheEntry(), 832 1, 2, GURL("http://blah/manifest/")); 833 834 job_ = handler_->MaybeLoadResource(request_.get(), empty_network_delegate_); 835 EXPECT_TRUE(job_.get()); 836 EXPECT_TRUE(job_->is_waiting()); 837 838 // We have to wait for completion of storage->FindResponseForMainRequest. 839 ScheduleNextTask(); 840 } 841 842 void Verify_MainResource_Blocked() { 843 EXPECT_FALSE(job_->is_waiting()); 844 EXPECT_FALSE(job_->is_delivering_appcache_response()); 845 846 EXPECT_EQ(0, handler_->found_cache_id_); 847 EXPECT_EQ(0, handler_->found_group_id_); 848 EXPECT_TRUE(handler_->found_manifest_url_.is_empty()); 849 EXPECT_TRUE(host_->preferred_manifest_url().is_empty()); 850 EXPECT_TRUE(host_->main_resource_blocked_); 851 EXPECT_TRUE(host_->blocked_manifest_url_ == GURL("http://blah/manifest/")); 852 853 TestFinished(); 854 } 855 856 // Test case helpers -------------------------------------------------- 857 858 AppCache* MakeNewCache() { 859 AppCache* cache = new AppCache( 860 mock_storage(), mock_storage()->NewCacheId()); 861 cache->set_complete(true); 862 AppCacheGroup* group = new AppCacheGroup( 863 mock_storage(), GURL("http://blah/manifest"), 864 mock_storage()->NewGroupId()); 865 group->AddCache(cache); 866 return cache; 867 } 868 869 MockAppCacheStorage* mock_storage() { 870 return reinterpret_cast<MockAppCacheStorage*>(mock_service_->storage()); 871 } 872 873 // Data members -------------------------------------------------- 874 875 scoped_ptr<base::WaitableEvent> test_finished_event_; 876 std::stack<base::Closure> task_stack_; 877 scoped_ptr<MockAppCacheService> mock_service_; 878 scoped_ptr<AppCacheBackendImpl> backend_impl_; 879 scoped_ptr<MockFrontend> mock_frontend_; 880 scoped_ptr<MockAppCachePolicy> mock_policy_; 881 AppCacheHost* host_; 882 net::URLRequestContext empty_context_; 883 net::NetworkDelegate* empty_network_delegate_; 884 scoped_ptr<MockURLRequest> request_; 885 scoped_ptr<AppCacheRequestHandler> handler_; 886 scoped_refptr<AppCacheURLRequestJob> job_; 887 net::URLRequest::ProtocolFactory* orig_http_factory_; 888 889 static scoped_ptr<base::Thread> io_thread_; 890 static net::URLRequestJob* mock_factory_job_; 891 }; 892 893 // static 894 scoped_ptr<base::Thread> AppCacheRequestHandlerTest::io_thread_; 895 net::URLRequestJob* AppCacheRequestHandlerTest::mock_factory_job_ = NULL; 896 897 TEST_F(AppCacheRequestHandlerTest, MainResource_Miss) { 898 RunTestOnIOThread(&AppCacheRequestHandlerTest::MainResource_Miss); 899 } 900 901 TEST_F(AppCacheRequestHandlerTest, MainResource_Hit) { 902 RunTestOnIOThread(&AppCacheRequestHandlerTest::MainResource_Hit); 903 } 904 905 TEST_F(AppCacheRequestHandlerTest, MainResource_Fallback) { 906 RunTestOnIOThread(&AppCacheRequestHandlerTest::MainResource_Fallback); 907 } 908 909 TEST_F(AppCacheRequestHandlerTest, MainResource_FallbackOverride) { 910 RunTestOnIOThread( 911 &AppCacheRequestHandlerTest::MainResource_FallbackOverride); 912 } 913 914 TEST_F(AppCacheRequestHandlerTest, SubResource_Miss_WithNoCacheSelected) { 915 RunTestOnIOThread( 916 &AppCacheRequestHandlerTest::SubResource_Miss_WithNoCacheSelected); 917 } 918 919 TEST_F(AppCacheRequestHandlerTest, SubResource_Miss_WithCacheSelected) { 920 RunTestOnIOThread( 921 &AppCacheRequestHandlerTest::SubResource_Miss_WithCacheSelected); 922 } 923 924 TEST_F(AppCacheRequestHandlerTest, 925 SubResource_Miss_WithWaitForCacheSelection) { 926 RunTestOnIOThread( 927 &AppCacheRequestHandlerTest::SubResource_Miss_WithWaitForCacheSelection); 928 } 929 930 TEST_F(AppCacheRequestHandlerTest, SubResource_Hit) { 931 RunTestOnIOThread(&AppCacheRequestHandlerTest::SubResource_Hit); 932 } 933 934 TEST_F(AppCacheRequestHandlerTest, SubResource_RedirectFallback) { 935 RunTestOnIOThread(&AppCacheRequestHandlerTest::SubResource_RedirectFallback); 936 } 937 938 TEST_F(AppCacheRequestHandlerTest, SubResource_NoRedirectFallback) { 939 RunTestOnIOThread( 940 &AppCacheRequestHandlerTest::SubResource_NoRedirectFallback); 941 } 942 943 TEST_F(AppCacheRequestHandlerTest, SubResource_Network) { 944 RunTestOnIOThread(&AppCacheRequestHandlerTest::SubResource_Network); 945 } 946 947 TEST_F(AppCacheRequestHandlerTest, DestroyedHost) { 948 RunTestOnIOThread(&AppCacheRequestHandlerTest::DestroyedHost); 949 } 950 951 TEST_F(AppCacheRequestHandlerTest, DestroyedHostWithWaitingJob) { 952 RunTestOnIOThread(&AppCacheRequestHandlerTest::DestroyedHostWithWaitingJob); 953 } 954 955 TEST_F(AppCacheRequestHandlerTest, UnsupportedScheme) { 956 RunTestOnIOThread(&AppCacheRequestHandlerTest::UnsupportedScheme); 957 } 958 959 TEST_F(AppCacheRequestHandlerTest, CanceledRequest) { 960 RunTestOnIOThread(&AppCacheRequestHandlerTest::CanceledRequest); 961 } 962 963 TEST_F(AppCacheRequestHandlerTest, WorkerRequest) { 964 RunTestOnIOThread(&AppCacheRequestHandlerTest::WorkerRequest); 965 } 966 967 TEST_F(AppCacheRequestHandlerTest, MainResource_Blocked) { 968 RunTestOnIOThread(&AppCacheRequestHandlerTest::MainResource_Blocked); 969 } 970 971 } // namespace appcache 972
