TaskScheduler: migrate appcache database over to use it.

content/browser/appcache/appcache_unittest.cc

 // Copyright 2014 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 <stddef.h>
 #include <stdint.h>
 
+#include "base/test/scoped_task_environment.h"
 #include "content/browser/appcache/appcache.h"
 #include "content/browser/appcache/appcache_host.h"
 #include "content/browser/appcache/mock_appcache_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 namespace {
 
 class MockAppCacheFrontend : public AppCacheFrontend {
@@ skipping 11 matching lines @@
                           const AppCacheErrorDetails& details) override {}
   void OnLogMessage(int host_id,
                     AppCacheLogLevel log_level,
                     const std::string& message) override {}
   void OnContentBlocked(int host_id, const GURL& manifest_url) override {}
 };
 
 }  // namespace
 
 class AppCacheTest : public testing::Test {
+  base::test::ScopedTaskEnvironment scoped_task_environment_;
 };
 
-TEST(AppCacheTest, CleanupUnusedCache) {
+TEST_F(AppCacheTest, CleanupUnusedCache) {
   MockAppCacheService service;
   MockAppCacheFrontend frontend;
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), 111));
   cache->set_complete(true);
   scoped_refptr<AppCacheGroup> group(
       new AppCacheGroup(service.storage(), GURL("http://blah/manifest"), 111));
   group->AddCache(cache.get());
 
   AppCacheHost host1(1, &frontend, &service);
   AppCacheHost host2(2, &frontend, &service);
 
   host1.AssociateCompleteCache(cache.get());
   host2.AssociateCompleteCache(cache.get());
 
   host1.AssociateNoCache(GURL());
   host2.AssociateNoCache(GURL());
 }
 
-TEST(AppCacheTest, AddModifyRemoveEntry) {
+TEST_F(AppCacheTest, AddModifyRemoveEntry) {
   MockAppCacheService service;
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), 111));
 
   EXPECT_TRUE(cache->entries().empty());
   EXPECT_EQ(0L, cache->cache_size());
 
   const GURL kFooUrl("http://foo.com");
   const int64_t kFooResponseId = 1;
   const int64_t kFooSize = 100;
   AppCacheEntry entry1(AppCacheEntry::MASTER, kFooResponseId, kFooSize);
@@ skipping 23 matching lines @@
 
   EXPECT_EQ(entry2.types(), cache->GetEntry(kBarUrl)->types());  // unchanged
 
   cache->RemoveEntry(kBarUrl);
   EXPECT_EQ(kFooSize, cache->cache_size());
   cache->RemoveEntry(kFooUrl);
   EXPECT_EQ(0L, cache->cache_size());
   EXPECT_TRUE(cache->entries().empty());
 }
 
-TEST(AppCacheTest, InitializeWithManifest) {
+TEST_F(AppCacheTest, InitializeWithManifest) {
   MockAppCacheService service;
 
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), 1234));
   EXPECT_TRUE(cache->fallback_namespaces_.empty());
   EXPECT_TRUE(cache->online_whitelist_namespaces_.empty());
   EXPECT_FALSE(cache->online_whitelist_all_);
 
   AppCacheManifest manifest;
   manifest.explicit_urls.insert("http://one.com");
   manifest.explicit_urls.insert("http://two.com");
@@ skipping 23 matching lines @@
   EXPECT_EQ(GURL("http://w1.com"), whitelist[0].namespace_url);
   EXPECT_EQ(GURL("http://w2.com"), whitelist[1].namespace_url);
   EXPECT_TRUE(cache->online_whitelist_all_);
 
   // Ensure collections in manifest were taken over by the cache rather than
   // copied.
   EXPECT_TRUE(manifest.fallback_namespaces.empty());
   EXPECT_TRUE(manifest.online_whitelist_namespaces.empty());
 }
 
-TEST(AppCacheTest, FindResponseForRequest) {
+TEST_F(AppCacheTest, FindResponseForRequest) {
   MockAppCacheService service;
 
   const GURL kOnlineNamespaceUrl("http://blah/online_namespace");
   const GURL kFallbackEntryUrl1("http://blah/fallback_entry1");
   const GURL kFallbackNamespaceUrl1("http://blah/fallback_namespace/");
   const GURL kFallbackEntryUrl2("http://blah/fallback_entry2");
   const GURL kFallbackNamespaceUrl2("http://blah/fallback_namespace/longer");
   const GURL kManifestUrl("http://blah/manifest");
   const GURL kForeignExplicitEntryUrl("http://blah/foreign");
   const GURL kInOnlineNamespaceUrl(
@@ skipping 191 matching lines @@
       &network_namespace);
   EXPECT_TRUE(found);
   EXPECT_EQ(kInterceptResponseId, entry.response_id());
   EXPECT_EQ(kInterceptNamespaceEntry,
             cache->GetInterceptEntryUrl(intercept_namespace));
   EXPECT_FALSE(fallback_entry.has_response_id());
   EXPECT_TRUE(fallback_namespace.is_empty());
   EXPECT_FALSE(network_namespace);
 }
 
-TEST(AppCacheTest, FindInterceptPatternResponseForRequest) {
+TEST_F(AppCacheTest, FindInterceptPatternResponseForRequest) {
   MockAppCacheService service;
 
   // Setup an appcache with an intercept namespace that uses pattern matching.
   const GURL kInterceptNamespaceBase("http://blah/intercept_namespace/");
   const GURL kInterceptPatternNamespace(
       kInterceptNamespaceBase.Resolve("*.hit*"));
   const GURL kInterceptNamespaceEntry("http://blah/intercept_resource");
   const int64_t kInterceptResponseId = 1;
   AppCacheManifest manifest;
   manifest.intercept_namespaces.push_back(
@@ skipping 50 matching lines @@
       &network_namespace);
   EXPECT_TRUE(found);
   EXPECT_EQ(kInterceptResponseId, entry.response_id());
   EXPECT_EQ(kInterceptNamespaceEntry,
             cache->GetInterceptEntryUrl(intercept_namespace));
   EXPECT_FALSE(fallback_entry.has_response_id());
   EXPECT_TRUE(fallback_namespace.is_empty());
   EXPECT_FALSE(network_namespace);
 }
 
-TEST(AppCacheTest, FindFallbackPatternResponseForRequest) {
+TEST_F(AppCacheTest, FindFallbackPatternResponseForRequest) {
   MockAppCacheService service;
 
   // Setup an appcache with a fallback namespace that uses pattern matching.
   const GURL kFallbackNamespaceBase("http://blah/fallback_namespace/");
   const GURL kFallbackPatternNamespace(
       kFallbackNamespaceBase.Resolve("*.hit*"));
   const GURL kFallbackNamespaceEntry("http://blah/fallback_resource");
   const int64_t kFallbackResponseId = 1;
   AppCacheManifest manifest;
   manifest.fallback_namespaces.push_back(
@@ skipping 50 matching lines @@
       &network_namespace);
   EXPECT_TRUE(found);
   EXPECT_FALSE(entry.has_response_id());
   EXPECT_EQ(kFallbackResponseId, fallback_entry.response_id());
   EXPECT_EQ(kFallbackNamespaceEntry,
             cache->GetFallbackEntryUrl(fallback_namespace));
   EXPECT_TRUE(intercept_namespace.is_empty());
   EXPECT_FALSE(network_namespace);
 }
 
-
-TEST(AppCacheTest, FindNetworkNamespacePatternResponseForRequest) {
+TEST_F(AppCacheTest, FindNetworkNamespacePatternResponseForRequest) {
   MockAppCacheService service;
 
   // Setup an appcache with a network namespace that uses pattern matching.
   const GURL kNetworkNamespaceBase("http://blah/network_namespace/");
   const GURL kNetworkPatternNamespace(
       kNetworkNamespaceBase.Resolve("*.hit*"));
   AppCacheManifest manifest;
   manifest.online_whitelist_namespaces.push_back(
       AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE, kNetworkPatternNamespace,
                 GURL(), true));
@@ skipping 21 matching lines @@
       GURL("http://blah/network_namespace/path.hit"),
       &entry, &intercept_namespace,
       &fallback_entry, &fallback_namespace,
       &network_namespace);
   EXPECT_TRUE(found);
   EXPECT_TRUE(network_namespace);
   EXPECT_FALSE(entry.has_response_id());
   EXPECT_FALSE(fallback_entry.has_response_id());
 }
 
-TEST(AppCacheTest, ToFromDatabaseRecords) {
+TEST_F(AppCacheTest, ToFromDatabaseRecords) {
   // Setup a cache with some entries.
   const int64_t kCacheId = 1234;
   const int64_t kGroupId = 4321;
   const GURL kManifestUrl("http://foo.com/manifest");
   const GURL kInterceptUrl("http://foo.com/intercept.html");
   const GURL kFallbackUrl("http://foo.com/fallback.html");
   const GURL kWhitelistUrl("http://foo.com/whitelist*");
   const std::string kData(
     "CACHE MANIFEST\r"
     "CHROMIUM-INTERCEPT:\r"
@@ skipping 64 matching lines @@
   EXPECT_EQ(kFallbackUrl,
             cache->GetFallbackEntryUrl(GURL("http://foo.com/")));
   EXPECT_EQ(1 + 2 + 3, cache->cache_size());
   EXPECT_EQ(APPCACHE_NETWORK_NAMESPACE,
             cache->online_whitelist_namespaces_[0].type);
   EXPECT_TRUE(cache->online_whitelist_namespaces_[0].is_pattern);
   EXPECT_EQ(kWhitelistUrl,
             cache->online_whitelist_namespaces_[0].namespace_url);
 }
 
-TEST(AppCacheTest, IsNamespaceMatch) {
+TEST_F(AppCacheTest, IsNamespaceMatch) {
   AppCacheNamespace prefix;
   prefix.namespace_url = GURL("http://foo.com/prefix");
   prefix.is_pattern = false;
   EXPECT_TRUE(prefix.IsMatch(
       GURL("http://foo.com/prefix_and_anothing_goes")));
   EXPECT_FALSE(prefix.IsMatch(
       GURL("http://foo.com/nope")));
 
   AppCacheNamespace bar_no_star;
   bar_no_star.namespace_url = GURL("http://foo.com/bar");
@@ skipping 53 matching lines @@
   EXPECT_TRUE(star_greediness.IsMatch(
       GURL("http://foo.com/a/b/01234567890abcdef/b")));
   EXPECT_TRUE(star_greediness.IsMatch(
       GURL("http://foo.com/a/b/01234567890abcdef/b01234567890abcdef/b")));
   EXPECT_TRUE(star_greediness.IsMatch(
       GURL("http://foo.com/a/b/01234567890abcdef_eat_some_more_characters_"
            "/and_even_more_for_the_heck_of_it/01234567890abcdef/b")));
 }
 
 }  // namespace content