Third-party appcache blocking.

webkit/appcache/appcache_request_handler_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stack>
 #include <string>
 #include <vector>
 
 #include "base/message_loop.h"
 #include "base/threading/thread.h"
 #include "base/synchronization/waitable_event.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_error_job.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_backend_impl.h"
 #include "webkit/appcache/appcache_request_handler.h"
 #include "webkit/appcache/appcache_url_request_job.h"
+#include "webkit/appcache/mock_appcache_policy.h"
 #include "webkit/appcache/mock_appcache_service.h"
 
 namespace appcache {
 
 static const int kMockProcessId = 1;
 
 class AppCacheRequestHandlerTest : public testing::Test {
  public:
   class MockFrontend : public AppCacheFrontend {
    public:
@@ skipping 134 matching lines @@
     io_thread_->message_loop()->PostTask(
         FROM_HERE, new WrapperTask<Method>(this, method));
     test_finished_event_->Wait();
   }
 
   void SetUpTest() {
     DCHECK(MessageLoop::current() == io_thread_->message_loop());
     orig_http_factory_ = net::URLRequest::Deprecated::RegisterProtocolFactory(
         "http", MockHttpJobFactory);
     mock_service_.reset(new MockAppCacheService);
+    mock_policy_.reset(new MockAppCachePolicy);
+    mock_service_->set_appcache_policy(mock_policy_.get());
     mock_frontend_.reset(new MockFrontend);
     backend_impl_.reset(new AppCacheBackendImpl);
     backend_impl_->Initialize(mock_service_.get(), mock_frontend_.get(),
                               kMockProcessId);
     const int kHostId = 1;
     backend_impl_->RegisterHost(kHostId);
     host_ = backend_impl_->GetHost(kHostId);
   }
 
   void TearDownTest() {
     DCHECK(MessageLoop::current() == io_thread_->message_loop());
     DCHECK(!mock_factory_job_);
     net::URLRequest::Deprecated::RegisterProtocolFactory(
         "http", orig_http_factory_);
     orig_http_factory_ = NULL;
     job_ = NULL;
     handler_.reset();
     request_.reset();
     backend_impl_.reset();
     mock_frontend_.reset();
     mock_service_.reset();
+    mock_policy_.reset();
     host_ = NULL;
   }
 
   void TestFinished() {
     // We unwind the stack prior to finishing up to let stack
     // based objects get deleted.
     DCHECK(MessageLoop::current() == io_thread_->message_loop());
     MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
         this, &AppCacheRequestHandlerTest::TestFinishedUnwound));
   }
@@ skipping 523 matching lines @@
     worker_host = backend_impl_->GetHost(kAbandonedWorkerHostId);
     EXPECT_EQ(NULL, backend_impl_->GetHost(kNonExsitingHostId));
     worker_host->SelectCacheForWorker(kNonExsitingHostId, kMockProcessId);
     handler_.reset(worker_host->CreateRequestHandler(
         request_.get(), ResourceType::SHARED_WORKER));
     EXPECT_FALSE(handler_.get());
 
     TestFinished();
   }
 
+  // MainResource_Blocked --------------------------------------------------
+
+  void MainResource_Blocked() {
+    PushNextTask(NewRunnableMethod(
+       this, &AppCacheRequestHandlerTest::Verify_MainResource_Blocked));
+
+    request_.reset(new MockURLRequest(GURL("http://blah/")));
+    handler_.reset(host_->CreateRequestHandler(request_.get(),
+                                               ResourceType::MAIN_FRAME));
+    EXPECT_TRUE(handler_.get());
+
+    mock_policy_->can_load_return_value_ = false;
+    mock_storage()->SimulateFindMainResource(
+        AppCacheEntry(AppCacheEntry::EXPLICIT, 1),
+        GURL(), AppCacheEntry(),
+        1, GURL("http://blah/manifest/"));
+
+    job_ = handler_->MaybeLoadResource(request_.get());
+    EXPECT_TRUE(job_.get());
+    EXPECT_TRUE(job_->is_waiting());
+
+    // We have to wait for completion of storage->FindResponseForMainRequest.
+    ScheduleNextTask();
+  }
+
+  void Verify_MainResource_Blocked() {
+    EXPECT_FALSE(job_->is_waiting());
+    EXPECT_FALSE(job_->is_delivering_appcache_response());
+
+    EXPECT_EQ(0, handler_->found_cache_id_);
+    EXPECT_TRUE(handler_->found_manifest_url_.is_empty());
+    EXPECT_TRUE(host_->preferred_manifest_url().is_empty());
+

[michaeln, 2011/09/05 19:49:31]

does it make sense to also verify these additional host data members?

host_->main_resource_blocked_;
host_->blocked_manifest_url_;

[marja, 2011/09/06 09:09:28]

Done.

+    TestFinished();
+  }
+
   // Test case helpers --------------------------------------------------
 
   AppCache* MakeNewCache() {
     AppCache* cache = new AppCache(
         mock_service_.get(), mock_storage()->NewCacheId());
     cache->set_complete(true);
     AppCacheGroup* group = new AppCacheGroup(
         mock_service_.get(), GURL("http://blah/manifest"),
         mock_storage()->NewGroupId());
     group->AddCache(cache);
     return cache;
   }
 
   MockAppCacheStorage* mock_storage() {
     return reinterpret_cast<MockAppCacheStorage*>(mock_service_->storage());
   }
 
   // Data members --------------------------------------------------
 
   scoped_ptr<base::WaitableEvent> test_finished_event_;
   std::stack<Task*> task_stack_;
   scoped_ptr<MockAppCacheService> mock_service_;
   scoped_ptr<AppCacheBackendImpl> backend_impl_;
   scoped_ptr<MockFrontend> mock_frontend_;
+  scoped_ptr<MockAppCachePolicy> mock_policy_;
   AppCacheHost* host_;
   scoped_ptr<MockURLRequest> request_;
   scoped_ptr<AppCacheRequestHandler> handler_;
   scoped_refptr<AppCacheURLRequestJob> job_;
   net::URLRequest::ProtocolFactory* orig_http_factory_;
 
   static scoped_ptr<base::Thread> io_thread_;
   static net::URLRequestJob* mock_factory_job_;
 };
 
@@ skipping 64 matching lines @@
 }
 
 TEST_F(AppCacheRequestHandlerTest, CanceledRequest) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::CanceledRequest);
 }
 
 TEST_F(AppCacheRequestHandlerTest, WorkerRequest) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::WorkerRequest);
 }
 
+TEST_F(AppCacheRequestHandlerTest, MainResource_Blocked) {
+  RunTestOnIOThread(&AppCacheRequestHandlerTest::MainResource_Blocked);
+}
+
 }  // namespace appcache
 
 // AppCacheRequestHandlerTest is expected to always live longer than the
 // runnable methods.  This lets us call NewRunnableMethod on its instances.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(appcache::AppCacheRequestHandlerTest);