Fix some loose ends around recently introduced AppCache INTERCEPT namespaces

webkit/appcache/appcache.h

 // 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.
 
 #ifndef WEBKIT_APPCACHE_APPCACHE_H_
 #define WEBKIT_APPCACHE_APPCACHE_H_
 
 #include <map>
 #include <set>
 #include <vector>
@@ skipping 42 matching lines @@
 
   // Removes an entry from the EntryMap, the URL must be in the set.
   void RemoveEntry(const GURL& url);
 
   // Do not store the returned object as it could be deleted anytime.
   AppCacheEntry* GetEntry(const GURL& url);
   const AppCacheEntry* GetEntryWithResponseId(int64 response_id);
 
   const EntryMap& entries() const { return entries_; }
 
-  // Returns the URL of the resource used as the fallback for 'namespace_url'.
-  GURL GetFallbackEntryUrl(const GURL& namespace_url) const;
+  // Returns the URL of the resource used as entry for 'namespace_url'.
+  GURL GetFallbackEntryUrl(const GURL& namespace_url) const {
+    return GetNamespaceEntryUrl(fallback_namespaces_, namespace_url);
+  }
+  GURL GetInterceptEntryUrl(const GURL& namespace_url) const {
+    return GetNamespaceEntryUrl(intercept_namespaces_, namespace_url);
+  }
 
   AppCacheHosts& associated_hosts() { return associated_hosts_; }
 
   bool IsNewerThan(AppCache* cache) const {
     // TODO(michaeln): revisit, the system clock can be set
     // back in time which would confuse this logic.
     if (update_time_ > cache->update_time_)
       return true;
 
     // Tie breaker. Newer caches have a larger cache ID.
@@ skipping 25 matching lines @@
   // to represent this cache.
   void ToDatabaseRecords(
       const AppCacheGroup* group,
       AppCacheDatabase::CacheRecord* cache_record,
       std::vector<AppCacheDatabase::EntryRecord>* entries,
       std::vector<AppCacheDatabase::NamespaceRecord>* intercepts,
       std::vector<AppCacheDatabase::NamespaceRecord>* fallbacks,
       std::vector<AppCacheDatabase::OnlineWhiteListRecord>* whitelists);
 
   bool 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);
 
   // Populates the 'infos' vector with an element per entry in the appcache.
   void ToResourceInfoVector(AppCacheResourceInfoVector* infos) const;
 
   static bool IsInNetworkNamespace(
       const GURL& url,
       const std::vector<GURL> &namespaces);
 
  private:
   friend class AppCacheGroup;
@@ skipping 10 matching lines @@
   // FindResponseForRequest helpers
   const Namespace* FindInterceptNamespace(const GURL& url) {
     return FindNamespace(intercept_namespaces_, url);
   }
   const Namespace* FindFallbackNamespace(const GURL& url) {
     return FindNamespace(fallback_namespaces_, url);
   }
   const Namespace* FindNamespace(const NamespaceVector& namespaces,
                                  const GURL& url);
 
+  GURL GetNamespaceEntryUrl(const NamespaceVector& namespaces,
+                            const GURL& namespace_url) const;
+
   // Use AppCacheHost::Associate*Cache() to manipulate host association.
   void AssociateHost(AppCacheHost* host) {
     associated_hosts_.insert(host);
   }
   void UnassociateHost(AppCacheHost* host);
 
   const int64 cache_id_;
   scoped_refptr<AppCacheGroup> owning_group_;
   AppCacheHosts associated_hosts_;
 
@@ skipping 15 matching lines @@
   AppCacheService* service_;
 
   FRIEND_TEST_ALL_PREFIXES(AppCacheTest, InitializeWithManifest);
 
   DISALLOW_COPY_AND_ASSIGN(AppCache);
 };
 
 }  // namespace appcache
 
 #endif  // WEBKIT_APPCACHE_APPCACHE_H_