AppCache - Don't ignore network namespace entries when '*' is in the list.

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 134 matching lines @@
                   fallback.target_url));
   }
 
   // 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);
 
-  if (!online_whitelist_all_) {
-    for (size_t i = 0; i < whitelists.size(); ++i) {
-      online_whitelist_namespaces_.push_back(whitelists.at(i).namespace_url);
-    }
-  }
+  for (size_t i = 0; i < whitelists.size(); ++i)
+    online_whitelist_namespaces_.push_back(whitelists.at(i).namespace_url);
 }
 
 void AppCache::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) {
   DCHECK(group && cache_record && entries && fallbacks && whitelists);
@@ skipping 32 matching lines @@
   for (size_t i = 0; i < fallback_namespaces_.size(); ++i) {
     fallbacks->push_back(AppCacheDatabase::NamespaceRecord());
     AppCacheDatabase::NamespaceRecord& record = fallbacks->back();
     record.cache_id = cache_id_;
     record.origin = origin;
     record.type = FALLBACK_NAMESPACE;
     record.namespace_url = fallback_namespaces_[i].namespace_url;
     record.target_url = fallback_namespaces_[i].target_url;
   }
 
-  if (!online_whitelist_all_) {
-    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];
-    }
+  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, 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()) {
@@ skipping 77 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