Move all remaining appcache-related code to content namespace

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"
-#include "webkit/browser/appcache/appcache.h"
-#include "webkit/browser/appcache/appcache_host.h"
-
-using appcache::AppCache;
-using appcache::AppCacheDatabase;
-using appcache::AppCacheEntry;
-using appcache::AppCacheFrontend;
-using appcache::AppCacheGroup;
-using appcache::AppCacheHost;
-using appcache::AppCacheInfo;
-using appcache::AppCacheErrorDetails;
-using appcache::AppCacheEventID;
-using appcache::APPCACHE_FALLBACK_NAMESPACE;
-using appcache::APPCACHE_INTERCEPT_NAMESPACE;
-using appcache::AppCacheLogLevel;
-using appcache::Manifest;
-using appcache::Namespace;
-using appcache::NamespaceVector;
-using appcache::APPCACHE_NETWORK_NAMESPACE;
-using appcache::PARSE_MANIFEST_ALLOWING_INTERCEPTS;
-using appcache::PARSE_MANIFEST_PER_STANDARD;
-using appcache::AppCacheStatus;
 
 namespace content {
 
 namespace {
 
 class MockAppCacheFrontend : public AppCacheFrontend {
  public:
   virtual void OnCacheSelected(int host_id, const AppCacheInfo& info) OVERRIDE {
   }
   virtual void OnStatusChanged(const std::vector<int>& host_ids,
@@ skipping 86 matching lines @@
 
   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;
   manifest.explicit_urls.insert("http://one.com");
   manifest.explicit_urls.insert("http://two.com");
   manifest.fallback_namespaces.push_back(
-      Namespace(APPCACHE_FALLBACK_NAMESPACE, GURL("http://fb1.com"),
+      AppCacheNamespace(APPCACHE_FALLBACK_NAMESPACE, GURL("http://fb1.com"),
                 GURL("http://fbone.com"), true));
   manifest.online_whitelist_namespaces.push_back(
-      Namespace(APPCACHE_NETWORK_NAMESPACE, GURL("http://w1.com"), GURL(), false));
+      AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE, GURL("http://w1.com"),
+          GURL(), false));
   manifest.online_whitelist_namespaces.push_back(
-      Namespace(APPCACHE_NETWORK_NAMESPACE, GURL("http://w2.com"), GURL(), false));
+      AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE, GURL("http://w2.com"),
+          GURL(), false));
   manifest.online_whitelist_all = true;
 
   cache->InitializeWithManifest(&manifest);
-  const std::vector<Namespace>& fallbacks =
+  const std::vector<AppCacheNamespace>& fallbacks =
       cache->fallback_namespaces_;
   size_t expected = 1;
   EXPECT_EQ(expected, fallbacks.size());
   EXPECT_EQ(GURL("http://fb1.com"), fallbacks[0].namespace_url);
   EXPECT_EQ(GURL("http://fbone.com"), fallbacks[0].target_url);
   EXPECT_TRUE(fallbacks[0].is_pattern);
-  const NamespaceVector& whitelist = cache->online_whitelist_namespaces_;
+  const AppCacheNamespaceVector& whitelist =
+      cache->online_whitelist_namespaces_;
   expected = 2;
   EXPECT_EQ(expected, whitelist.size());
   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());
@@ skipping 24 matching lines @@
 
   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;
   manifest.online_whitelist_namespaces.push_back(
-      Namespace(APPCACHE_NETWORK_NAMESPACE, kOnlineNamespaceUrl,
-                GURL(), false));
+      AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE, kOnlineNamespaceUrl,
+          GURL(), false));
   manifest.online_whitelist_namespaces.push_back(
-      Namespace(APPCACHE_NETWORK_NAMESPACE,
-                kOnlineNamespaceWithinOtherNamespaces,
-                GURL(), false));
+      AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE,
+          kOnlineNamespaceWithinOtherNamespaces, GURL(), false));
   manifest.fallback_namespaces.push_back(
-      Namespace(APPCACHE_FALLBACK_NAMESPACE, kFallbackNamespaceUrl1,
-                kFallbackEntryUrl1, false));
+      AppCacheNamespace(APPCACHE_FALLBACK_NAMESPACE, kFallbackNamespaceUrl1,
+          kFallbackEntryUrl1, false));
   manifest.fallback_namespaces.push_back(
-      Namespace(APPCACHE_FALLBACK_NAMESPACE, kFallbackNamespaceUrl2,
-                kFallbackEntryUrl2, false));
+      AppCacheNamespace(APPCACHE_FALLBACK_NAMESPACE, kFallbackNamespaceUrl2,
+          kFallbackEntryUrl2, false));
   manifest.intercept_namespaces.push_back(
-      Namespace(APPCACHE_INTERCEPT_NAMESPACE, kInterceptNamespace,
-                kInterceptNamespaceEntry, false));
+      AppCacheNamespace(APPCACHE_INTERCEPT_NAMESPACE, kInterceptNamespace,
+          kInterceptNamespaceEntry, false));
   manifest.intercept_namespaces.push_back(
-      Namespace(APPCACHE_INTERCEPT_NAMESPACE, kInterceptNamespaceWithinFallback,
-                kInterceptNamespaceEntry, false));
+      AppCacheNamespace(APPCACHE_INTERCEPT_NAMESPACE,
+          kInterceptNamespaceWithinFallback, kInterceptNamespaceEntry, false));
 
   // Create a cache with some namespaces and entries.
   scoped_refptr<AppCache> cache(new AppCache(service.storage(), 1234));
   cache->InitializeWithManifest(&manifest);
   cache->AddEntry(
       kFallbackEntryUrl1,
       AppCacheEntry(AppCacheEntry::FALLBACK, kFallbackResponseId1));
   cache->AddEntry(
       kFallbackEntryUrl2,
       AppCacheEntry(AppCacheEntry::FALLBACK, kFallbackResponseId2));
@@ skipping 154 matching lines @@
   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;
   manifest.intercept_namespaces.push_back(
-      Namespace(APPCACHE_INTERCEPT_NAMESPACE, kInterceptPatternNamespace,
-                kInterceptNamespaceEntry, true));
+      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);
 
   // See that the pattern match works.
   bool found = false;
   AppCacheEntry entry;
@@ skipping 49 matching lines @@
   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;
   manifest.fallback_namespaces.push_back(
-      Namespace(APPCACHE_FALLBACK_NAMESPACE, kFallbackPatternNamespace,
+      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);
 
   // See that the pattern match works.
   bool found = false;
@@ 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;
   manifest.online_whitelist_namespaces.push_back(
-      Namespace(APPCACHE_NETWORK_NAMESPACE, kNetworkPatternNamespace,
+      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;
   AppCacheEntry entry;
   AppCacheEntry fallback_entry;
@@ skipping 97 matching lines @@
             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) {
-  Namespace prefix;
+  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")));
 
-  Namespace bar_no_star;
+  AppCacheNamespace bar_no_star;
   bar_no_star.namespace_url = GURL("http://foo.com/bar");
   bar_no_star.is_pattern = true;
   EXPECT_TRUE(bar_no_star.IsMatch(
       GURL("http://foo.com/bar")));
   EXPECT_FALSE(bar_no_star.IsMatch(
       GURL("http://foo.com/bar/nope")));
 
-  Namespace bar_star;
+  AppCacheNamespace bar_star;
   bar_star.namespace_url = GURL("http://foo.com/bar/*");
   bar_star.is_pattern = true;
   EXPECT_TRUE(bar_star.IsMatch(
       GURL("http://foo.com/bar/")));
   EXPECT_TRUE(bar_star.IsMatch(
       GURL("http://foo.com/bar/should_match")));
   EXPECT_FALSE(bar_star.IsMatch(
       GURL("http://foo.com/not_bar/should_not_match")));
 
-  Namespace star_bar_star;
+  AppCacheNamespace star_bar_star;
   star_bar_star.namespace_url = GURL("http://foo.com/*/bar/*");
   star_bar_star.is_pattern = true;
   EXPECT_TRUE(star_bar_star.IsMatch(
       GURL("http://foo.com/any/bar/should_match")));
   EXPECT_TRUE(star_bar_star.IsMatch(
       GURL("http://foo.com/any/bar/")));
   EXPECT_FALSE(star_bar_star.IsMatch(
       GURL("http://foo.com/any/not_bar/no_match")));
 
-  Namespace query_star_edit;
+  AppCacheNamespace query_star_edit;
   query_star_edit.namespace_url = GURL("http://foo.com/query?id=*&verb=edit*");
   query_star_edit.is_pattern = true;
   EXPECT_TRUE(query_star_edit.IsMatch(
       GURL("http://foo.com/query?id=1234&verb=edit&option=blue")));
   EXPECT_TRUE(query_star_edit.IsMatch(
       GURL("http://foo.com/query?id=12345&option=blue&verb=edit")));
   EXPECT_FALSE(query_star_edit.IsMatch(
       GURL("http://foo.com/query?id=12345&option=blue&verb=print")));
   EXPECT_TRUE(query_star_edit.IsMatch(
       GURL("http://foo.com/query?id=123&verb=print&verb=edit")));
 
-  Namespace star_greediness;
+  AppCacheNamespace star_greediness;
   star_greediness.namespace_url = GURL("http://foo.com/*/b");
   star_greediness.is_pattern = true;
   EXPECT_TRUE(star_greediness.IsMatch(
       GURL("http://foo.com/a/b")));
   EXPECT_TRUE(star_greediness.IsMatch(
       GURL("http://foo.com/a/wxy/z/b")));
   EXPECT_TRUE(star_greediness.IsMatch(
       GURL("http://foo.com/a/b/b")));
   EXPECT_TRUE(star_greediness.IsMatch(
       GURL("http://foo.com/b/b")));
   EXPECT_TRUE(star_greediness.IsMatch(
       GURL("http://foo.com/a/b/b/b/b/b")));
   EXPECT_TRUE(star_greediness.IsMatch(
       GURL("http://foo.com/a/b/b/b/a/b")));
   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