Move all remaining appcache-related code to content namespace

content/browser/appcache/appcache.cc

 // Copyright (c) 2012 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 "webkit/browser/appcache/appcache.h"
+#include "content/browser/appcache/appcache.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
-#include "webkit/browser/appcache/appcache_executable_handler.h"
-#include "webkit/browser/appcache/appcache_group.h"
-#include "webkit/browser/appcache/appcache_host.h"
-#include "webkit/browser/appcache/appcache_storage.h"
-#include "webkit/common/appcache/appcache_interfaces.h"
+#include "content/browser/appcache/appcache_executable_handler.h"
+#include "content/browser/appcache/appcache_group.h"
+#include "content/browser/appcache/appcache_host.h"
+#include "content/browser/appcache/appcache_storage.h"
+#include "content/common/appcache_interfaces.h"
 
-namespace appcache {
+namespace content {
 
 AppCache::AppCache(AppCacheStorage* storage, int64 cache_id)
     : cache_id_(cache_id),
       owning_group_(NULL),
       online_whitelist_all_(false),
       is_complete_(false),
       cache_size_(0),
       storage_(storage) {
   storage_->working_set()->AddCache(this);
 }
@@ skipping 80 matching lines @@
   scoped_ptr<AppCacheExecutableHandler> own_ptr =
       storage_->service()->handler_factory()->
           CreateHandler(handler_url, handler_source);
   handler = own_ptr.release();
   if (!handler)
     return NULL;
   executable_handlers_[response_id] = handler;
   return handler;
 }
 
-GURL AppCache::GetNamespaceEntryUrl(const NamespaceVector& namespaces,
+GURL AppCache::GetNamespaceEntryUrl(const AppCacheNamespaceVector& namespaces,
                                     const GURL& namespace_url) const {
   size_t count = namespaces.size();
   for (size_t i = 0; i < count; ++i) {
     if (namespaces[i].namespace_url == namespace_url)
       return namespaces[i].target_url;
   }
   NOTREACHED();
   return GURL();
 }
 
 namespace {
 bool SortNamespacesByLength(
-    const Namespace& lhs, const Namespace& rhs) {
+    const AppCacheNamespace& lhs, const AppCacheNamespace& rhs) {
   return lhs.namespace_url.spec().length() > rhs.namespace_url.spec().length();
 }
 }
 
 void AppCache::InitializeWithManifest(Manifest* manifest) {
   DCHECK(manifest);
   intercept_namespaces_.swap(manifest->intercept_namespaces);
   fallback_namespaces_.swap(manifest->fallback_namespaces);
   online_whitelist_namespaces_.swap(manifest->online_whitelist_namespaces);
   online_whitelist_all_ = manifest->online_whitelist_all;
@@ skipping 32 matching lines @@
   // Sort the fallback namespaces by url string length, longest to shortest,
   // since longer matches trump when matching a url to a namespace.
   std::sort(intercept_namespaces_.begin(), intercept_namespaces_.end(),
             SortNamespacesByLength);
   std::sort(fallback_namespaces_.begin(), fallback_namespaces_.end(),
             SortNamespacesByLength);
 
   for (size_t i = 0; i < whitelists.size(); ++i) {
     const AppCacheDatabase::OnlineWhiteListRecord& record = whitelists.at(i);
     online_whitelist_namespaces_.push_back(
-        Namespace(APPCACHE_NETWORK_NAMESPACE,
+        AppCacheNamespace(APPCACHE_NETWORK_NAMESPACE,
                   record.namespace_url,
                   GURL(),
                   record.is_pattern));
   }
 }
 
 void AppCache::ToDatabaseRecords(
     const AppCacheGroup* group,
     AppCacheDatabase::CacheRecord* cache_record,
     std::vector<AppCacheDatabase::EntryRecord>* entries,
@@ skipping 66 matching lines @@
 
   AppCacheEntry* entry = GetEntry(url_no_ref);
   if (entry) {
     *found_entry = *entry;
     return true;
   }
 
   if ((*found_network_namespace = IsInNetworkNamespace(url_no_ref)))
     return true;
 
-  const Namespace* intercept_namespace = FindInterceptNamespace(url_no_ref);
+  const AppCacheNamespace* intercept_namespace =
+      FindInterceptNamespace(url_no_ref);
   if (intercept_namespace) {
     entry = GetEntry(intercept_namespace->target_url);
     DCHECK(entry);
     *found_entry = *entry;
     *found_intercept_namespace = intercept_namespace->namespace_url;
     return true;
   }
 
-  const Namespace* fallback_namespace = FindFallbackNamespace(url_no_ref);
+  const AppCacheNamespace* fallback_namespace =
+      FindFallbackNamespace(url_no_ref);
   if (fallback_namespace) {
     entry = GetEntry(fallback_namespace->target_url);
     DCHECK(entry);
     *found_fallback_entry = *entry;
     *found_fallback_namespace = fallback_namespace->namespace_url;
     return true;
   }
 
   *found_network_namespace = online_whitelist_all_;
   return *found_network_namespace;
@@ skipping 12 matching lines @@
     info.is_intercept = iter->second.IsIntercept();
     info.is_fallback = iter->second.IsFallback();
     info.is_foreign = iter->second.IsForeign();
     info.is_explicit = iter->second.IsExplicit();
     info.size = iter->second.response_size();
     info.response_id = iter->second.response_id();
   }
 }
 
 // static
-const Namespace* AppCache::FindNamespace(
-    const NamespaceVector& namespaces,
+const AppCacheNamespace* AppCache::FindNamespace(
+    const AppCacheNamespaceVector& namespaces,
     const GURL& url) {
   size_t count = namespaces.size();
   for (size_t i = 0; i < count; ++i) {
     if (namespaces[i].IsMatch(url))
       return &namespaces[i];
   }
   return NULL;
 }
 
-}  // namespace appcache
+}  // namespace content