Fix some loose ends around recently introduced AppCache INTERCEPT namespaces

webkit/appcache/appcache_storage_impl.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 "webkit/appcache/appcache_storage_impl.h"
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <vector>
@@ skipping 833 matching lines @@
       int64 preferred_cache_id,
       AppCacheDatabase::NamespaceRecordVector* namespaces,
       NetworkNamespaceHelper* network_namespace_helper);
   bool FindFirstValidNamespace(const NamespaceRecordPtrVector& namespaces);
 
   GURL url_;
   GURL preferred_manifest_url_;
   std::set<int64> cache_ids_in_use_;
   AppCacheEntry entry_;
   AppCacheEntry fallback_entry_;
-  GURL fallback_url_;
+  GURL namespace_entry_url_;
   int64 cache_id_;
   int64 group_id_;
   GURL manifest_url_;
 };
 
 
 
 void AppCacheStorageImpl::FindMainResponseTask::Run() {
   // NOTE: The heuristics around choosing amoungst multiple candidates
   // is underspecified, and just plain not fully understood. This needs
@@ skipping 132 matching lines @@
     if (database_->FindEntry((*iter)->cache_id, (*iter)->target_url,
                              &entry_record)) {
       AppCacheDatabase::GroupRecord group_record;
       if ((entry_record.flags & AppCacheEntry::FOREIGN) ||
           !database_->FindGroupForCache(entry_record.cache_id, &group_record)) {
         continue;
       }
       manifest_url_ = group_record.manifest_url;
       group_id_ = group_record.group_id;
       cache_id_ = (*iter)->cache_id;
-      if ((*iter)->type == FALLBACK_NAMESPACE) {
-        fallback_url_ = (*iter)->target_url;
-        fallback_entry_ = AppCacheEntry(
-            entry_record.flags, entry_record.response_id);
-      } else {
+      namespace_entry_url_ = (*iter)->target_url;
+      if ((*iter)->type == FALLBACK_NAMESPACE)
+        fallback_entry_ = AppCacheEntry(entry_record.flags,
+                                        entry_record.response_id);
+      else
         entry_ = AppCacheEntry(entry_record.flags, entry_record.response_id);
-      }
       return true;  // We found one.
     }
   }
   return false;  // We didn't find a match.
 }
 
 void AppCacheStorageImpl::FindMainResponseTask::RunCompleted() {
   storage_->CallOnMainResponseFound(
-      &delegates_, url_, entry_, fallback_url_, fallback_entry_,
+      &delegates_, url_, entry_, namespace_entry_url_, fallback_entry_,
       cache_id_, group_id_, manifest_url_);
 }
 
 // MarkEntryAsForeignTask -------
 
 class AppCacheStorageImpl::MarkEntryAsForeignTask : public DatabaseTask {
  public:
   MarkEntryAsForeignTask(
       AppCacheStorageImpl* storage, const GURL& url, int64 cache_id)
       : DatabaseTask(storage), cache_id_(cache_id), entry_url_(url) {}
@@ skipping 413 matching lines @@
         GURL(), AppCacheEntry(),
         cache.get() ? cache->cache_id() : kNoCacheId,
         group.get() ? group->group_id() : kNoCacheId,
         group.get() ? group->manifest_url() : GURL());
   }
 }
 
 void AppCacheStorageImpl::CallOnMainResponseFound(
     DelegateReferenceVector* delegates,
     const GURL& url, const AppCacheEntry& entry,
-    const GURL& fallback_url, const AppCacheEntry& fallback_entry,
+    const GURL& namespace_entry_url, const AppCacheEntry& fallback_entry,
     int64 cache_id, int64 group_id, const GURL& manifest_url) {
   FOR_EACH_DELEGATE(
       (*delegates),
       OnMainResponseFound(url, entry,
-                          fallback_url, fallback_entry,
+                          namespace_entry_url, fallback_entry,
                           cache_id, group_id, manifest_url));
 }
 
 void AppCacheStorageImpl::FindResponseForSubRequest(
     AppCache* cache, const GURL& url,
     AppCacheEntry* found_entry, AppCacheEntry* found_fallback_entry,
     bool* found_network_namespace) {
   DCHECK(cache && cache->is_complete());
 
   // When a group is forcibly deleted, all subresource loads for pages
   // using caches in the group will result in a synthesized network errors.
   // Forcible deletion is not a function that is covered by the HTML5 spec.
   if (cache->owning_group()->is_being_deleted()) {
     *found_entry = AppCacheEntry();
     *found_fallback_entry = AppCacheEntry();
     *found_network_namespace = false;
     return;
   }
 
   GURL fallback_namespace_not_used;
+  GURL intercept_namespace_not_used;
   cache->FindResponseForRequest(
-      url, found_entry, found_fallback_entry,
-      &fallback_namespace_not_used, found_network_namespace);
+      url, found_entry, &intercept_namespace_not_used,
+      found_fallback_entry, &fallback_namespace_not_used,
+      found_network_namespace);
 }
 
 void AppCacheStorageImpl::MarkEntryAsForeign(
     const GURL& entry_url, int64 cache_id) {
   AppCache* cache = working_set_.GetCache(cache_id);
   if (cache) {
     AppCacheEntry* entry = cache->GetEntry(entry_url);
     DCHECK(entry);
     if (entry)
       entry->add_types(AppCacheEntry::FOREIGN);
@@ skipping 219 matching lines @@
     Disable();
     if (!is_incognito_) {
       VLOG(1) << "Deleting existing appcache data and starting over.";
       db_thread_->PostTask(
           FROM_HERE, base::Bind(&DeleteDirectory, cache_directory_));
     }
   }
 }
 
 }  // namespace appcache