Rename AppCache's Manifest to AppCacheManifest.

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 "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 {
@@ skipping 90 matching lines @@
 }
 
 TEST(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_);
 
-  Manifest manifest;
+  AppCacheManifest manifest;
   manifest.explicit_urls.insert("http://one.com");
   manifest.explicit_urls.insert("http://two.com");
   manifest.fallback_namespaces.push_back(
       AppCacheNamespace(APPCACHE_FALLBACK_NAMESPACE, GURL("http://fb1.com"),
                 GURL("http://fbone.com"), true));
   manifest.online_whitelist_namespaces.push_back(
       AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE, GURL("http://w1.com"),
           GURL(), false));
   manifest.online_whitelist_namespaces.push_back(
       AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE, GURL("http://w2.com"),
@@ skipping 45 matching lines @@
   const GURL kOnlineNamespaceWithinOtherNamespaces(
       "http://blah/fallback_namespace/intercept_namespace/1/online");
 
   const int64 kFallbackResponseId1 = 1;
   const int64 kFallbackResponseId2 = 2;
   const int64 kManifestResponseId = 3;
   const int64 kForeignExplicitResponseId = 4;
   const int64 kExplicitInOnlineNamespaceResponseId = 5;
   const int64 kInterceptResponseId = 6;
 
-  Manifest manifest;
+  AppCacheManifest manifest;
   manifest.online_whitelist_namespaces.push_back(
       AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE, kOnlineNamespaceUrl,
           GURL(), false));
   manifest.online_whitelist_namespaces.push_back(
       AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE,
           kOnlineNamespaceWithinOtherNamespaces, GURL(), false));
   manifest.fallback_namespaces.push_back(
       AppCacheNamespace(APPCACHE_FALLBACK_NAMESPACE, kFallbackNamespaceUrl1,
           kFallbackEntryUrl1, false));
   manifest.fallback_namespaces.push_back(
@@ skipping 170 matching lines @@
 
 TEST(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 kInterceptResponseId = 1;
-  Manifest manifest;
+  AppCacheManifest manifest;
   manifest.intercept_namespaces.push_back(
       AppCacheNamespace(APPCACHE_INTERCEPT_NAMESPACE,
           kInterceptPatternNamespace, kInterceptNamespaceEntry, true));
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), 1234));
   cache->InitializeWithManifest(&manifest);
   cache->AddEntry(
       kInterceptNamespaceEntry,
       AppCacheEntry(AppCacheEntry::INTERCEPT, kInterceptResponseId));
   cache->set_complete(true);
 
@@ skipping 50 matching lines @@
 
 TEST(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 kFallbackResponseId = 1;
-  Manifest manifest;
+  AppCacheManifest manifest;
   manifest.fallback_namespaces.push_back(
       AppCacheNamespace(APPCACHE_FALLBACK_NAMESPACE, kFallbackPatternNamespace,
                 kFallbackNamespaceEntry, true));
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), 1234));
   cache->InitializeWithManifest(&manifest);
   cache->AddEntry(
       kFallbackNamespaceEntry,
       AppCacheEntry(AppCacheEntry::FALLBACK, kFallbackResponseId));
   cache->set_complete(true);
 
@@ skipping 49 matching lines @@
 }
 
 
 TEST(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*"));
-  Manifest manifest;
+  AppCacheManifest manifest;
   manifest.online_whitelist_namespaces.push_back(
       AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE, kNetworkPatternNamespace,
                 GURL(), true));
   manifest.online_whitelist_all = false;
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), 1234));
   cache->InitializeWithManifest(&manifest);
   cache->set_complete(true);
 
   // See that the pattern match works.
   bool found = false;
@@ skipping 35 matching lines @@
     "/intercept return /intercept.html\r"
     "FALLBACK:\r"
     "/ /fallback.html\r"
     "NETWORK:\r"
     "/whitelist* isPattern\r"
     "*\r");
   MockAppCacheService service;
   scoped_refptr<AppCacheGroup> group =
       new AppCacheGroup(service.storage(), kManifestUrl, kGroupId);
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), kCacheId));
-  Manifest manifest;
+  AppCacheManifest manifest;
   EXPECT_TRUE(ParseManifest(kManifestUrl, kData.c_str(), kData.length(),
                             PARSE_MANIFEST_ALLOWING_INTERCEPTS, manifest));
   cache->InitializeWithManifest(&manifest);
   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);
   cache->AddEntry(
       kManifestUrl,
@@ skipping 116 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