Third-party appcache blocking.

webkit/appcache/appcache_update_job_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 "testing/gtest/include/gtest/gtest.h"
 
 #include "base/stl_util.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_error_job.h"
 #include "net/url_request/url_request_job_factory.h"
 #include "net/url_request/url_request_test_job.h"
 #include "net/url_request/url_request_test_util.h"
 #include "webkit/appcache/appcache_group.h"
 #include "webkit/appcache/appcache_host.h"
-#include "webkit/appcache/appcache_policy.h"
+#include "webkit/appcache/appcache_request_handler.h"
 #include "webkit/appcache/appcache_response.h"
 #include "webkit/appcache/appcache_update_job.h"
 #include "webkit/appcache/mock_appcache_service.h"
+#include "webkit/glue/resource_type.h"
 
 namespace appcache {
 class AppCacheUpdateJobTest;
 
 namespace {
 
 const char kManifest1Contents[] =
     "CACHE MANIFEST\n"
     "explicit1\n"
     "FALLBACK:\n"
@@ skipping 512 matching lines @@
   }
 
  private:
   scoped_ptr<net::URLRequestJobFactory> job_factory_;
   scoped_refptr<net::URLRequestContext> request_context_;
 };
 
 class AppCacheUpdateJobTest : public testing::Test,
                               public AppCacheGroup::UpdateObserver {
  public:
-  class MockAppCachePolicy : public AppCachePolicy {
-   public:
-    MockAppCachePolicy()
-        : can_create_return_value_(net::OK), return_immediately_(true),
-          callback_(NULL) {
-    }
-
-    virtual bool CanLoadAppCache(const GURL& manifest_url) {
-      return true;
-    }
-
-    virtual int CanCreateAppCache(const GURL& manifest_url,
-                                  net::CompletionCallback* callback) {
-      requested_manifest_url_ = manifest_url;
-      callback_ = callback;
-      if (return_immediately_)
-        return can_create_return_value_;
-
-      MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
-              this, &MockAppCachePolicy::CompleteCanCreateAppCache));
-      return net::ERR_IO_PENDING;
-    }
-
-    void CompleteCanCreateAppCache() {
-      callback_->Run(can_create_return_value_);
-    }
-
-    int can_create_return_value_;
-    bool return_immediately_;
-    GURL requested_manifest_url_;
-    net::CompletionCallback* callback_;
-  };
-
-
   AppCacheUpdateJobTest()
       : do_checks_after_update_finished_(false),
         expect_group_obsolete_(false),
         expect_group_has_cache_(false),
         expect_old_cache_(NULL),
         expect_newest_cache_(NULL),
         expect_non_null_update_time_(false),
         tested_manifest_(NONE),
         tested_manifest_path_override_(NULL) {
     io_thread_.reset(new IOThread("AppCacheUpdateJob IO test thread"));
@@ skipping 39 matching lines @@
     EXPECT_EQ(expected, events.size());
     EXPECT_EQ(expected, events[0].first.size());
     EXPECT_EQ(host.host_id(), events[0].first[0]);
     EXPECT_EQ(CHECKING_EVENT, events[0].second);
 
     // Abort as we're not testing actual URL fetches in this test.
     delete update;
     UpdateFinished();
   }
 
-  void ImmediatelyBlockCacheAttemptTest() {
-    BlockCacheAttemptTest(true);
-  }
-
-  void DelayedBlockCacheAttemptTest() {
-    BlockCacheAttemptTest(false);
-  }
-
-  void BlockCacheAttemptTest(bool immediately) {
-    ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
-
-    GURL manifest_url = GURL("http://failme");
-
-    // Setup to block the cache attempt immediately.
-    policy_.return_immediately_ = immediately;
-    policy_.can_create_return_value_ = net::ERR_ACCESS_DENIED;
-
-    MakeService();
-    group_ = new AppCacheGroup(service_.get(), manifest_url,
-                               service_->storage()->NewGroupId());
-
-    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
-    group_->update_job_ = update;
-
-    MockFrontend mock_frontend;
-    AppCacheHost host(1, &mock_frontend, service_.get());
-
-    update->StartUpdate(&host, GURL());
-    EXPECT_EQ(manifest_url, policy_.requested_manifest_url_);
-
-    // Verify state.
-    EXPECT_EQ(AppCacheUpdateJob::CACHE_ATTEMPT, update->update_type_);
-    EXPECT_EQ(AppCacheUpdateJob::FETCH_MANIFEST, update->internal_state_);
-    EXPECT_EQ(AppCacheGroup::CHECKING, group_->update_status());
-
-    // Verify notifications.
-    MockFrontend::RaisedEvents& events = mock_frontend.raised_events_;
-    size_t expected = 1;
-    EXPECT_EQ(expected, events.size());
-    EXPECT_EQ(1U, events[0].first.size());
-    EXPECT_EQ(host.host_id(), events[0].first[0]);
-    EXPECT_EQ(CHECKING_EVENT, events[0].second);
-
-    WaitForUpdateToFinish();
-  }
-
   void StartUpgradeAttemptTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     {
       MakeService();
       group_ = new AppCacheGroup(service_.get(), GURL("http://failme"),
                                  service_->storage()->NewGroupId());
 
       // Give the group some existing caches.
       AppCache* cache1 = MakeCacheForGroup(1, 111);
@@ skipping 348 matching lines @@
     EXPECT_TRUE(update->manifest_fetcher_ != NULL);
 
     WaitForUpdateToFinish();
   }
 
   void BasicCacheAttemptSuccessTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     GURL manifest_url = MockHttpServer::GetMockUrl("files/manifest1");
 
-    // We also test the async AppCachePolicy return path in this test case.
-    policy_.return_immediately_ = false;
-    policy_.can_create_return_value_ = net::OK;
-
     MakeService();
     group_ = new AppCacheGroup(
         service_.get(), manifest_url,
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     update->StartUpdate(host, GURL());
-    EXPECT_EQ(manifest_url, policy_.requested_manifest_url_);;
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
     tested_manifest_ = MANIFEST1;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
@@ skipping 775 matching lines @@
 
     group_ = new AppCacheGroup(
         service_.get(), kManifestUrl,
         service_->storage()->NewGroupId());
     scoped_refptr<AppCache> cache(
         MakeCacheForGroup(service_->storage()->NewCacheId(),
                           kManifestResponseId));
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
+    net::URLRequest url_request(kManifestUrl, NULL);
+    url_request.set_first_party_for_cookies(kManifestUrl);
+    delete host->CreateRequestHandler(&url_request, ResourceType::MAIN_FRAME);
     host->SelectCache(MockHttpServer::GetMockUrl("files/empty1"),
                       kNoCacheId, kManifestUrl);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     tested_manifest_ = EMPTY_MANIFEST;
     tested_manifest_path_override_ = "files/notmodified";
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
     expect_newest_cache_ = cache;  // unchanged
@@ skipping 955 matching lines @@
     MakeService();
     group_ = new AppCacheGroup(
         service_.get(), manifest_url,
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     update->StartUpdate(host, GURL());
-    EXPECT_EQ(manifest_url, policy_.requested_manifest_url_);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
     tested_manifest_ = NONE;
     MockFrontend::HostIds host_ids(1, host->host_id());
     frontend->AddExpectedEvent(host_ids, CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void CrossOriginHttpsDeniedTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     GURL manifest_url = MockHttpServer::GetMockHttpsUrl(
         "files/invalid_cross_origin_https_manifest");
 
     MakeService();
     group_ = new AppCacheGroup(
         service_.get(), manifest_url,
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     update->StartUpdate(host, GURL());
-    EXPECT_EQ(manifest_url, policy_.requested_manifest_url_);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;
     tested_manifest_ = NONE;
     MockFrontend::HostIds host_ids(1, host->host_id());
     frontend->AddExpectedEvent(host_ids, CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void WaitForUpdateToFinish() {
     if (group_->update_status() == AppCacheGroup::IDLE)
       UpdateFinished();
     else
       group_->AddUpdateObserver(this);
   }
 
   void OnUpdateComplete(AppCacheGroup* group) {
     ASSERT_EQ(group_, group);
     protect_newest_cache_ = group->newest_complete_cache();
     UpdateFinished();
   }
 
-  void OnContentBlocked(AppCacheGroup* group) {
-  }
-
   void UpdateFinished() {
     // We unwind the stack prior to finishing up to let stack-based objects
     // get deleted.
     MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
             this, &AppCacheUpdateJobTest::UpdateFinishedUnwound));
   }
 
   void UpdateFinishedUnwound() {
     EXPECT_EQ(AppCacheGroup::IDLE, group_->update_status());
     EXPECT_TRUE(group_->update_job() == NULL);
     if (do_checks_after_update_finished_)
       VerifyExpectations();
 
     // Clean up everything that was created on the IO thread.
     protect_newest_cache_ = NULL;
     group_ = NULL;
     STLDeleteContainerPointers(hosts_.begin(), hosts_.end());
     STLDeleteContainerPointers(frontends_.begin(), frontends_.end());
     response_infos_.clear();
     service_.reset(NULL);
 
     event_->Signal();
   }
 
   void MakeService() {
     service_.reset(new MockAppCacheService());
     service_->set_request_context(io_thread_->request_context());
-    service_->set_appcache_policy(&policy_);
   }
 
   AppCache* MakeCacheForGroup(int64 cache_id, int64 manifest_response_id) {
     AppCache* cache = new AppCache(service_.get(), cache_id);
     cache->set_complete(true);
     cache->set_update_time(base::Time::Now());
     group_->AddCache(cache);
 
     // Add manifest entry to cache.
     cache->AddEntry(group_->manifest_url(),
@@ skipping 292 matching lines @@
     EMPTY_FILE_MANIFEST,
     PENDING_MASTER_NO_UPDATE,
   };
 
   scoped_ptr<IOThread> io_thread_;
 
   scoped_ptr<MockAppCacheService> service_;
   scoped_refptr<AppCacheGroup> group_;
   scoped_refptr<AppCache> protect_newest_cache_;
   scoped_ptr<base::WaitableEvent> event_;
-  MockAppCachePolicy policy_;
 
   scoped_ptr<AppCacheResponseWriter> response_writer_;
   scoped_ptr<net::CompletionCallbackImpl<AppCacheUpdateJobTest> >
       write_callback_;
 
   // Hosts used by an async test that need to live until update job finishes.
   // Otherwise, test can put host on the stack instead of here.
   std::vector<AppCacheHost*> hosts_;
 
   // Response infos used by an async test that need to live until update job
@@ skipping 73 matching lines @@
   EXPECT_EQ(host.host_id(), events[1].first[0]);
   EXPECT_EQ(appcache::DOWNLOADING_EVENT, events[1].second);
 
   EXPECT_EQ(AppCacheGroup::DOWNLOADING, group->update_status());
 }
 
 TEST_F(AppCacheUpdateJobTest, StartCacheAttempt) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::StartCacheAttemptTest);
 }
 
-TEST_F(AppCacheUpdateJobTest, ImmediatelyBlockCacheAttemptTest) {
-  RunTestOnIOThread(&AppCacheUpdateJobTest::ImmediatelyBlockCacheAttemptTest);
-}
-
-TEST_F(AppCacheUpdateJobTest, DelayedBlockCacheAttemptTest) {
-  RunTestOnIOThread(&AppCacheUpdateJobTest::DelayedBlockCacheAttemptTest);
-}
-
 TEST_F(AppCacheUpdateJobTest, StartUpgradeAttempt) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::StartUpgradeAttemptTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, CacheAttemptFetchManifestFail) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CacheAttemptFetchManifestFailTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, UpgradeFetchManifestFail) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::UpgradeFetchManifestFailTest);
@@ skipping 187 matching lines @@
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsDenied) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsDeniedTest);
 }
 
 }  // namespace appcache
 
 // AppCacheUpdateJobTest is expected to always live longer than the
 // runnable methods.  This lets us call NewRunnableMethod on its instances.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(appcache::AppCacheUpdateJobTest);
-DISABLE_RUNNABLE_METHOD_REFCOUNT(
-    appcache::AppCacheUpdateJobTest::MockAppCachePolicy);