Third-party appcache blocking.

webkit/appcache/appcache_storage_impl_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 "base/message_loop.h"
 #include "base/threading/thread.h"
 #include "base/synchronization/waitable_event.h"
 #include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_database.h"
 #include "webkit/appcache/appcache_entry.h"
 #include "webkit/appcache/appcache_group.h"
-#include "webkit/appcache/appcache_policy.h"
 #include "webkit/appcache/appcache_service.h"
 #include "webkit/appcache/appcache_storage_impl.h"
 #include "webkit/quota/quota_manager.h"
 #include "webkit/tools/test_shell/simple_appcache_system.h"
 
 namespace appcache {
 
 namespace {
 
 const base::Time kZeroTime;
@@ skipping 54 matching lines @@
 
 }  // namespace
 
 class AppCacheStorageImplTest : public testing::Test {
  public:
   class MockStorageDelegate : public AppCacheStorage::Delegate {
    public:
     explicit MockStorageDelegate(AppCacheStorageImplTest* test)
         : loaded_cache_id_(0), stored_group_success_(false),
           would_exceed_quota_(false), obsoleted_success_(false),
-          found_cache_id_(kNoCacheId), found_blocked_by_policy_(false),
-          test_(test) {
+          found_cache_id_(kNoCacheId), test_(test) {
     }
 
     void OnCacheLoaded(AppCache* cache, int64 cache_id) {
       loaded_cache_ = cache;
       loaded_cache_id_ = cache_id;
       test_->ScheduleNextTask();
     }
 
     void OnGroupLoaded(AppCacheGroup* group, const GURL& manifest_url) {
       loaded_group_ = group;
@@ skipping 14 matching lines @@
 
     void OnGroupMadeObsolete(AppCacheGroup* group, bool success) {
       obsoleted_group_ = group;
       obsoleted_success_ = success;
       test_->ScheduleNextTask();
     }
 
     void OnMainResponseFound(const GURL& url, const AppCacheEntry& entry,
                              const GURL& fallback_url,
                              const AppCacheEntry& fallback_entry,
-                             int64 cache_id, const GURL& manifest_url,
-                             bool was_blocked_by_policy) {
+                             int64 cache_id, const GURL& manifest_url) {
       found_url_ = url;
       found_entry_ = entry;
       found_fallback_url_ = fallback_url;
       found_fallback_entry_ = fallback_entry;
       found_cache_id_ = cache_id;
       found_manifest_url_ = manifest_url;
-      found_blocked_by_policy_ = was_blocked_by_policy;
       test_->ScheduleNextTask();
     }
 
     scoped_refptr<AppCache> loaded_cache_;
     int64 loaded_cache_id_;
     scoped_refptr<AppCacheGroup> loaded_group_;
     GURL loaded_manifest_url_;
     scoped_refptr<AppCache> loaded_groups_newest_cache_;
     scoped_refptr<AppCacheGroup> stored_group_;
     bool stored_group_success_;
     bool would_exceed_quota_;
     scoped_refptr<AppCacheGroup> obsoleted_group_;
     bool obsoleted_success_;
     GURL found_url_;
     AppCacheEntry found_entry_;
     GURL found_fallback_url_;
     AppCacheEntry found_fallback_entry_;
     int64 found_cache_id_;
     GURL found_manifest_url_;
-    bool found_blocked_by_policy_;
     AppCacheStorageImplTest* test_;
   };
 
-  class MockAppCachePolicy : public AppCachePolicy {
-   public:
-    explicit MockAppCachePolicy(AppCacheStorageImplTest* test)
-        : can_load_return_value_(true), can_create_return_value_(0),
-          callback_(NULL), test_(test) {
-    }
-
-    virtual bool CanLoadAppCache(const GURL& manifest_url) {
-      requested_manifest_url_ = manifest_url;
-      return can_load_return_value_;
-    }
-
-    virtual int CanCreateAppCache(const GURL& manifest_url,
-                                  net::CompletionCallback* callback) {
-      requested_manifest_url_ = manifest_url;
-      callback_ = callback;
-      if (can_create_return_value_ == net::ERR_IO_PENDING)
-        test_->ScheduleNextTask();
-      return can_create_return_value_;
-    }
-
-    bool can_load_return_value_;
-    int can_create_return_value_;
-    GURL requested_manifest_url_;
-    net::CompletionCallback* callback_;
-    AppCacheStorageImplTest* test_;
-  };
-
   class MockQuotaManager : public quota::QuotaManager {
    public:
     MockQuotaManager()
       : QuotaManager(true /* is_incognito */, FilePath(),
                      io_thread->message_loop_proxy(),
                      db_thread->message_loop_proxy(),
                      NULL),
         async_(false) {}
 
     virtual void GetUsageAndQuota(
@@ skipping 105 matching lines @@
   }
 
   static void TearDownTestCase() {
     SimpleAppCacheSystem::set_thread_provider(NULL);
     io_thread.reset(NULL);
     db_thread.reset(NULL);
   }
 
   // Test harness --------------------------------------------------
 
-  AppCacheStorageImplTest()
-      : ALLOW_THIS_IN_INITIALIZER_LIST(policy_(this)) {
+  AppCacheStorageImplTest() {
   }
 
   template <class Method>
   void RunTestOnIOThread(Method method) {
     test_finished_event_ .reset(new base::WaitableEvent(false, false));
     io_thread->message_loop()->PostTask(
         FROM_HERE, new WrapperTask<Method>(this, method));
     test_finished_event_->Wait();
   }
 
@@ skipping 539 matching lines @@
     PushNextTask(NewRunnableMethod(
        this, &AppCacheStorageImplTest::Verify_FindNoMainResponse));
 
     // Conduct the test.
     storage()->FindResponseForMainRequest(kEntryUrl, GURL(), delegate());
     EXPECT_NE(kEntryUrl, delegate()->found_url_);
   }
 
   void Verify_FindNoMainResponse() {
     EXPECT_EQ(kEntryUrl, delegate()->found_url_);
-    // If the request was blocked by a policy, the manifest url is still valid.
-    EXPECT_TRUE(delegate()->found_manifest_url_.is_empty() ||
-                delegate()->found_blocked_by_policy_);
+    EXPECT_TRUE(delegate()->found_manifest_url_.is_empty());
     EXPECT_EQ(kNoCacheId, delegate()->found_cache_id_);
     EXPECT_EQ(kNoResponseId, delegate()->found_entry_.response_id());
     EXPECT_EQ(kNoResponseId, delegate()->found_fallback_entry_.response_id());
     EXPECT_TRUE(delegate()->found_fallback_url_.is_empty());
     EXPECT_EQ(0, delegate()->found_entry_.types());
     EXPECT_EQ(0, delegate()->found_fallback_entry_.types());
     TestFinished();
   }
 
   // BasicFindMainResponse  -------------------------------
 
   void BasicFindMainResponseInDatabase() {
-    BasicFindMainResponse(true, false);
+    BasicFindMainResponse(true);
   }
 
   void BasicFindMainResponseInWorkingSet() {
-    BasicFindMainResponse(false, false);
+    BasicFindMainResponse(false);
   }
 
-  void BlockFindMainResponseWithPolicyCheck() {
-    BasicFindMainResponse(true, true);
-  }
-
-  void BasicFindMainResponse(bool drop_from_working_set,
-                             bool block_with_policy_check) {
+  void BasicFindMainResponse(bool drop_from_working_set) {
     PushNextTask(NewRunnableMethod(
        this, &AppCacheStorageImplTest::Verify_BasicFindMainResponse));
 
-    policy_.can_load_return_value_ = !block_with_policy_check;
-    service()->set_appcache_policy(&policy_);
-
     // Setup some preconditions. Create a complete cache with an entry
     // in storage.
     MakeCacheAndGroup(kManifestUrl, 1, 1, true);
     cache_->AddEntry(kEntryUrl, AppCacheEntry(AppCacheEntry::EXPLICIT, 1));
     AppCacheDatabase::EntryRecord entry_record;
     entry_record.cache_id = 1;
     entry_record.url = kEntryUrl;
     entry_record.flags = AppCacheEntry::EXPLICIT;
     entry_record.response_id = 1;
     EXPECT_TRUE(database()->InsertEntry(&entry_record));
 
     // Optionally drop the cache/group pair from the working set.
     if (drop_from_working_set) {
       EXPECT_TRUE(cache_->HasOneRef());
       cache_ = NULL;
       EXPECT_TRUE(group_->HasOneRef());
       group_ = NULL;
     }
 
     // Conduct the test.
     storage()->FindResponseForMainRequest(kEntryUrl, GURL(), delegate());
     EXPECT_NE(kEntryUrl,  delegate()->found_url_);
   }
 
   void Verify_BasicFindMainResponse() {
-    EXPECT_EQ(kManifestUrl, policy_.requested_manifest_url_);
-    if (policy_.can_load_return_value_) {
-      EXPECT_EQ(kEntryUrl, delegate()->found_url_);
-      EXPECT_EQ(kManifestUrl, delegate()->found_manifest_url_);
-      EXPECT_FALSE(delegate()->found_blocked_by_policy_);
-      EXPECT_EQ(1, delegate()->found_cache_id_);
-      EXPECT_EQ(1, delegate()->found_entry_.response_id());
-      EXPECT_TRUE(delegate()->found_entry_.IsExplicit());
-      EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
-      TestFinished();
-    } else {
-      Verify_FindNoMainResponse();
-    }
+    EXPECT_EQ(kEntryUrl, delegate()->found_url_);
+    EXPECT_EQ(kManifestUrl, delegate()->found_manifest_url_);
+    EXPECT_EQ(1, delegate()->found_cache_id_);
+    EXPECT_EQ(1, delegate()->found_entry_.response_id());
+    EXPECT_TRUE(delegate()->found_entry_.IsExplicit());
+    EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
+    TestFinished();
   }
 
   // BasicFindMainFallbackResponse  -------------------------------
 
   void BasicFindMainFallbackResponseInDatabase() {
     BasicFindMainFallbackResponse(true);
   }
 
   void BasicFindMainFallbackResponseInWorkingSet() {
     BasicFindMainFallbackResponse(false);
@@ skipping 39 matching lines @@
 
     // Conduct the test. The test url is in both fallback namespace urls,
     // but should match the longer of the two.
     storage()->FindResponseForMainRequest(kFallbackTestUrl, GURL(), delegate());
     EXPECT_NE(kFallbackTestUrl, delegate()->found_url_);
   }
 
   void Verify_BasicFindMainFallbackResponse() {
     EXPECT_EQ(kFallbackTestUrl, delegate()->found_url_);
     EXPECT_EQ(kManifestUrl, delegate()->found_manifest_url_);
-    EXPECT_FALSE(delegate()->found_blocked_by_policy_);
     EXPECT_EQ(1, delegate()->found_cache_id_);
     EXPECT_FALSE(delegate()->found_entry_.has_response_id());
     EXPECT_EQ(2, delegate()->found_fallback_entry_.response_id());
     EXPECT_EQ(kEntryUrl2, delegate()->found_fallback_url_);
     EXPECT_TRUE(delegate()->found_fallback_entry_.IsFallback());
     TestFinished();
   }
 
   // FindMainResponseWithMultipleHits  -------------------------------
 
@@ skipping 54 matching lines @@
     fallback_namespace_record.origin = manifest_url.GetOrigin();
     EXPECT_TRUE(
         database()->InsertFallbackNameSpace(&fallback_namespace_record));
     cache_->fallback_namespaces_.push_back(
         FallbackNamespace(kFallbackNamespace, kEntryUrl2));
   }
 
   void Verify_FindMainResponseWithMultipleHits() {
     EXPECT_EQ(kEntryUrl, delegate()->found_url_);
     EXPECT_EQ(kManifestUrl3, delegate()->found_manifest_url_);
-    EXPECT_FALSE(delegate()->found_blocked_by_policy_);
     EXPECT_EQ(3, delegate()->found_cache_id_);
     EXPECT_EQ(3, delegate()->found_entry_.response_id());
     EXPECT_TRUE(delegate()->found_entry_.IsExplicit());
     EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
 
     // Conduct another test perferring kManifestUrl
     delegate_.reset(new MockStorageDelegate(this));
     PushNextTask(NewRunnableMethod(this,
         &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits2));
     storage()->FindResponseForMainRequest(kEntryUrl, kManifestUrl, delegate());
     EXPECT_NE(kEntryUrl, delegate()->found_url_);
   }
 
   void Verify_FindMainResponseWithMultipleHits2() {
     EXPECT_EQ(kEntryUrl, delegate()->found_url_);
     EXPECT_EQ(kManifestUrl, delegate()->found_manifest_url_);
-    EXPECT_FALSE(delegate()->found_blocked_by_policy_);
     EXPECT_EQ(1, delegate()->found_cache_id_);
     EXPECT_EQ(1, delegate()->found_entry_.response_id());
     EXPECT_TRUE(delegate()->found_entry_.IsExplicit());
     EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
 
     // Conduct the another test perferring kManifestUrl2
     delegate_.reset(new MockStorageDelegate(this));
     PushNextTask(NewRunnableMethod(this,
         &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits3));
     storage()->FindResponseForMainRequest(kEntryUrl, kManifestUrl2, delegate());
     EXPECT_NE(kEntryUrl, delegate()->found_url_);
   }
 
   void Verify_FindMainResponseWithMultipleHits3() {
     EXPECT_EQ(kEntryUrl, delegate()->found_url_);
     EXPECT_EQ(kManifestUrl2, delegate()->found_manifest_url_);
-    EXPECT_FALSE(delegate()->found_blocked_by_policy_);
     EXPECT_EQ(2, delegate()->found_cache_id_);
     EXPECT_EQ(2, delegate()->found_entry_.response_id());
     EXPECT_TRUE(delegate()->found_entry_.IsExplicit());
     EXPECT_FALSE(delegate()->found_fallback_entry_.has_response_id());
 
     // Conduct another test with no preferred manifest that hits the fallback.
     delegate_.reset(new MockStorageDelegate(this));
     PushNextTask(NewRunnableMethod(this,
         &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits4));
     storage()->FindResponseForMainRequest(
         kFallbackTestUrl, GURL(), delegate());
     EXPECT_NE(kFallbackTestUrl, delegate()->found_url_);
   }
 
   void Verify_FindMainResponseWithMultipleHits4() {
     EXPECT_EQ(kFallbackTestUrl, delegate()->found_url_);
     EXPECT_EQ(kManifestUrl3, delegate()->found_manifest_url_);
-    EXPECT_FALSE(delegate()->found_blocked_by_policy_);
     EXPECT_EQ(3, delegate()->found_cache_id_);
     EXPECT_FALSE(delegate()->found_entry_.has_response_id());
     EXPECT_EQ(3 + kFallbackEntryIdOffset,
               delegate()->found_fallback_entry_.response_id());
     EXPECT_TRUE(delegate()->found_fallback_entry_.IsFallback());
     EXPECT_EQ(kEntryUrl2, delegate()->found_fallback_url_);
 
     // Conduct another test preferring kManifestUrl2 that hits the fallback.
     delegate_.reset(new MockStorageDelegate(this));
     PushNextTask(NewRunnableMethod(this,
         &AppCacheStorageImplTest::Verify_FindMainResponseWithMultipleHits5));
     storage()->FindResponseForMainRequest(
         kFallbackTestUrl, kManifestUrl2, delegate());
     EXPECT_NE(kFallbackTestUrl, delegate()->found_url_);
   }
 
   void Verify_FindMainResponseWithMultipleHits5() {
     EXPECT_EQ(kFallbackTestUrl, delegate()->found_url_);
     EXPECT_EQ(kManifestUrl2, delegate()->found_manifest_url_);
-    EXPECT_FALSE(delegate()->found_blocked_by_policy_);
     EXPECT_EQ(2, delegate()->found_cache_id_);
     EXPECT_FALSE(delegate()->found_entry_.has_response_id());
     EXPECT_EQ(2 + kFallbackEntryIdOffset,
               delegate()->found_fallback_entry_.response_id());
     EXPECT_TRUE(delegate()->found_fallback_entry_.IsFallback());
     EXPECT_EQ(kEntryUrl2, delegate()->found_fallback_url_);
 
     TestFinished();
   }
 
@@ skipping 50 matching lines @@
     // We should not find anything for the foreign entry.
     PushNextTask(NewRunnableMethod(
         this, &AppCacheStorageImplTest::Verify_ExclusionNotFound,
         kEntryUrl, 1));
     storage()->FindResponseForMainRequest(kEntryUrl, GURL(), delegate());
   }
 
   void Verify_ExclusionNotFound(GURL expected_url, int phase) {
     EXPECT_EQ(expected_url, delegate()->found_url_);
     EXPECT_TRUE(delegate()->found_manifest_url_.is_empty());
-    EXPECT_FALSE(delegate()->found_blocked_by_policy_);
     EXPECT_EQ(kNoCacheId, delegate()->found_cache_id_);
     EXPECT_EQ(kNoResponseId, delegate()->found_entry_.response_id());
     EXPECT_EQ(kNoResponseId, delegate()->found_fallback_entry_.response_id());
     EXPECT_TRUE(delegate()->found_fallback_url_.is_empty());
     EXPECT_EQ(0, delegate()->found_entry_.types());
     EXPECT_EQ(0, delegate()->found_fallback_entry_.types());
 
     if (phase == 1) {
       // We should not find anything for the online namespace.
       PushNextTask(NewRunnableMethod(this,
@@ skipping 69 matching lines @@
 
       storage()->usage_map_[manifest_url.GetOrigin()] =
           default_entry.response_size();
     }
   }
 
   // Data members --------------------------------------------------
 
   scoped_ptr<base::WaitableEvent> test_finished_event_;
   std::stack<Task*> task_stack_;
-  MockAppCachePolicy policy_;
   scoped_ptr<AppCacheService> service_;
   scoped_ptr<MockStorageDelegate> delegate_;
   scoped_refptr<MockQuotaManagerProxy> mock_quota_manager_proxy_;
   scoped_refptr<AppCacheGroup> group_;
   scoped_refptr<AppCache> cache_;
   scoped_refptr<AppCache> cache2_;
 };
 
 
 TEST_F(AppCacheStorageImplTest, LoadCache_Miss) {
@@ skipping 52 matching lines @@
 TEST_F(AppCacheStorageImplTest, BasicFindMainResponseInDatabase) {
   RunTestOnIOThread(
       &AppCacheStorageImplTest::BasicFindMainResponseInDatabase);
 }
 
 TEST_F(AppCacheStorageImplTest, BasicFindMainResponseInWorkingSet) {
   RunTestOnIOThread(
       &AppCacheStorageImplTest::BasicFindMainResponseInWorkingSet);
 }
 
-TEST_F(AppCacheStorageImplTest, BlockFindMainResponseWithPolicyCheck) {
-  RunTestOnIOThread(
-      &AppCacheStorageImplTest::BlockFindMainResponseWithPolicyCheck);
-}
-
 TEST_F(AppCacheStorageImplTest, BasicFindMainFallbackResponseInDatabase) {
   RunTestOnIOThread(
       &AppCacheStorageImplTest::BasicFindMainFallbackResponseInDatabase);
 }
 
 TEST_F(AppCacheStorageImplTest, BasicFindMainFallbackResponseInWorkingSet) {
   RunTestOnIOThread(
       &AppCacheStorageImplTest::BasicFindMainFallbackResponseInWorkingSet);
 }
 
@@ skipping 12 matching lines @@
       &AppCacheStorageImplTest::FindMainResponseExclusionsInWorkingSet);
 }
 
 // That's all folks!
 
 }  // namespace appcache
 
 // AppCacheStorageImplTest is expected to always live longer than the
 // runnable methods.  This lets us call NewRunnableMethod on its instances.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(appcache::AppCacheStorageImplTest);