AppCache: Alter the relative priorities of online vs fallback namespaces.

webkit/appcache/appcache_storage_impl.cc

 // Copyright (c) 2010 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/appcache/appcache_storage_impl.h"
 
 #include "app/sql/connection.h"
 #include "app/sql/transaction.h"
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 540 matching lines @@
 
   GURL url_;
   std::set<int64> cache_ids_in_use_;
   AppCacheEntry entry_;
   AppCacheEntry fallback_entry_;
   GURL fallback_url_;
   int64 cache_id_;
   GURL manifest_url_;
 };
 
+// Helpers for FindMainResponseTask::Run()
 namespace {
 bool SortByLength(
     const AppCacheDatabase::FallbackNameSpaceRecord& lhs,
     const AppCacheDatabase::FallbackNameSpaceRecord& rhs) {
   return lhs.namespace_url.spec().length() > rhs.namespace_url.spec().length();
 }
-}
+
+class NetworkNamespaceHelper {
+ public:
+  explicit NetworkNamespaceHelper(AppCacheDatabase* database)
+      : database_(database) {
+  }
+
+  bool IsInNetworkNamespace(const GURL& url, int64 cache_id) {
+    static const std::vector<GURL> kEmptyVector;
+    typedef std::pair<WhiteListMap::iterator, bool> InsertResult;
+    InsertResult result = namespaces_map_.insert(
+        WhiteListMap::value_type(cache_id, kEmptyVector));
+    if (result.second)
+      GetOnlineWhiteListForCache(cache_id, &result.first->second);
+    return AppCache::IsInNetworkNamespace(url, result.first->second);
+  }
+
+ private:
+  void GetOnlineWhiteListForCache(
+      int64 cache_id, std::vector<GURL>* urls) {
+    DCHECK(urls && urls->empty());
+    typedef std::vector<AppCacheDatabase::OnlineWhiteListRecord>
+        WhiteListVector;
+    WhiteListVector records;
+    if (!database_->FindOnlineWhiteListForCache(cache_id, &records))
+      return;
+    WhiteListVector::const_iterator iter = records.begin();
+    while (iter != records.end()) {
+      urls->push_back(iter->namespace_url);
+      ++iter;
+    }
+  }
+
+  // Key is cache id
+  typedef std::map<int64, std::vector<GURL> > WhiteListMap;
+  WhiteListMap namespaces_map_;
+  AppCacheDatabase* database_;
+};
+}  // namespace
 
 void AppCacheStorageImpl::FindMainResponseTask::Run() {
   // We have a bias for hits from caches that are in use.
 
   // TODO(michaeln): The heuristics around choosing amoungst
   // multiple candidates is under specified, and just plain
   // not fully understood. Refine these over time. In particular,
   // * prefer candidates from newer caches
   // * take into account the cache associated with the document
   //   that initiated the navigation
@@ skipping 30 matching lines @@
     return;
   }
 
   // Sort by namespace url string length, longest to shortest,
   // since longer matches trump when matching a url to a namespace.
   std::sort(fallbacks.begin(), fallbacks.end(), SortByLength);
 
   bool has_candidate = false;
   GURL candidate_fallback_namespace;
   std::vector<AppCacheDatabase::FallbackNameSpaceRecord>::iterator iter;
+  NetworkNamespaceHelper network_namespace_helper(database_);
   for (iter = fallbacks.begin(); iter < fallbacks.end(); ++iter) {
+    // Skip this fallback namespace if the requested url falls into a network
+    // namespace of the containing appcache.
+    if (network_namespace_helper.IsInNetworkNamespace(url_, iter->cache_id))
+      continue;
+
     if (has_candidate &&
         (candidate_fallback_namespace.spec().length() >
          iter->namespace_url.spec().length())) {
       break;  // Stop iterating since longer namespace prefix matches win.
     }
 
     if (StartsWithASCII(url_.spec(), iter->namespace_url.spec(), true)) {
       bool is_cache_in_use = cache_ids_in_use_.find(iter->cache_id) !=
                              cache_ids_in_use_.end();
 
@@ skipping 699 matching lines @@
     Disable();
     if (!is_incognito_) {
       VLOG(1) << "Deleting existing appcache data and starting over.";
       AppCacheThread::PostTask(AppCacheThread::db(), FROM_HERE,
           NewRunnableFunction(DeleteDirectory, cache_directory_));
     }
   }
 }
 
 }  // namespace appcache