Fix some loose ends around recently introduced AppCache INTERCEPT namespaces

webkit/appcache/appcache.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 <algorithm>
 
 #include "webkit/appcache/appcache.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
@@ skipping 61 matching lines @@
 
 const AppCacheEntry* AppCache::GetEntryWithResponseId(int64 response_id) {
   for (EntryMap::const_iterator iter = entries_.begin();
        iter !=  entries_.end(); ++iter) {
     if (iter->second.response_id() == response_id)
       return &iter->second;
   }
   return NULL;
 }
 
-GURL AppCache::GetFallbackEntryUrl(const GURL& namespace_url) const {
-  size_t count = fallback_namespaces_.size();
+GURL AppCache::GetNamespaceEntryUrl(const NamespaceVector& namespaces,
+                                    const GURL& namespace_url) const {
+  size_t count = namespaces.size();
   for (size_t i = 0; i < count; ++i) {
-    if (fallback_namespaces_[i].namespace_url == namespace_url)
-      return fallback_namespaces_[i].target_url;
+    if (namespaces[i].namespace_url == namespace_url)
+      return namespaces[i].target_url;
   }
   NOTREACHED();
   return GURL();
 }
 
 namespace {
 bool SortNamespacesByLength(
     const Namespace& lhs, const Namespace& rhs) {
   return lhs.namespace_url.spec().length() > rhs.namespace_url.spec().length();
 }
@@ skipping 115 matching lines @@
     for (size_t i = 0; i < online_whitelist_namespaces_.size(); ++i) {
       whitelists->push_back(AppCacheDatabase::OnlineWhiteListRecord());
       AppCacheDatabase::OnlineWhiteListRecord& record = whitelists->back();
       record.cache_id = cache_id_;
       record.namespace_url = online_whitelist_namespaces_[i];
     }
   }
 }
 
 bool AppCache::FindResponseForRequest(const GURL& url,
-    AppCacheEntry* found_entry, AppCacheEntry* found_fallback_entry,
-    GURL* found_fallback_namespace, bool* found_network_namespace) {
+    AppCacheEntry* found_entry, GURL* found_intercept_namespace,
+    AppCacheEntry* found_fallback_entry, GURL* found_fallback_namespace,
+    bool* found_network_namespace) {
   // Ignore fragments when looking up URL in the cache.
   GURL url_no_ref;
   if (url.has_ref()) {
     GURL::Replacements replacements;
     replacements.ClearRef();
     url_no_ref = url.ReplaceComponents(replacements);
   } else {
     url_no_ref = url;
   }
 
   // 6.6.6 Changes to the networking model
 
   AppCacheEntry* entry = GetEntry(url_no_ref);
   if (entry) {
     *found_entry = *entry;
     return true;
   }
 
   if ((*found_network_namespace =
          IsInNetworkNamespace(url_no_ref, online_whitelist_namespaces_))) {
     return true;
   }
 
   const Namespace* 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);
   if (fallback_namespace) {
     entry = GetEntry(fallback_namespace->target_url);
     DCHECK(entry);
     *found_fallback_entry = *entry;
     *found_fallback_namespace = fallback_namespace->namespace_url;
     return true;
@@ skipping 41 matching lines @@
   // structures and algorithms that can be applied here and above.
   size_t count = namespaces.size();
   for (size_t i = 0; i < count; ++i) {
     if (StartsWithASCII(url.spec(), namespaces[i].spec(), true))
       return true;
   }
   return false;
 }
 
 }  // namespace appcache