Fix some loose ends around recently introduced AppCache INTERCEPT namespaces

webkit/appcache/appcache_host.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_host.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "webkit/appcache/appcache.h"
@@ skipping 32 matching lines @@
 
 AppCacheHost::AppCacheHost(int host_id, AppCacheFrontend* frontend,
                            AppCacheService* service)
     : host_id_(host_id),
       spawning_host_id_(kNoHostId), spawning_process_id_(0),
       parent_host_id_(kNoHostId), parent_process_id_(0),
       pending_main_resource_cache_id_(kNoCacheId),
       pending_selected_cache_id_(kNoCacheId),
       frontend_(frontend), service_(service),
       pending_callback_param_(NULL),
-      main_resource_was_fallback_(false), main_resource_blocked_(false),
+      main_resource_was_namespace_entry_(false),
+      main_resource_blocked_(false),
       associated_cache_info_pending_(false) {
 }
 
 AppCacheHost::~AppCacheHost() {
   FOR_EACH_OBSERVER(Observer, observers_, OnDestructionImminent(this));
   if (associated_cache_.get())
     associated_cache_->UnassociateHost(this);
   if (group_being_updated_.get())
     group_being_updated_->RemoveUpdateObserver(this);
   service_->storage()->CancelDelegateCallbacks(this);
@@ skipping 89 matching lines @@
     return;
   }
   FinishCacheSelection(NULL, NULL);
 }
 
 // TODO(michaeln): change method name to MarkEntryAsForeign for consistency
 void AppCacheHost::MarkAsForeignEntry(const GURL& document_url,
                                       int64 cache_document_was_loaded_from) {
   // The document url is not the resource url in the fallback case.
   service_->storage()->MarkEntryAsForeign(
-      main_resource_was_fallback_ ? fallback_url_ : document_url,
+      main_resource_was_namespace_entry_ ? namespace_entry_url_ : document_url,
       cache_document_was_loaded_from);
   SelectCache(document_url, kNoCacheId, GURL());
 }
 
 void AppCacheHost::GetStatusWithCallback(const GetStatusCallback& callback,
                                          void* callback_param) {
   DCHECK(pending_start_update_callback_.is_null() &&
          pending_swap_cache_callback_.is_null() &&
          pending_get_status_callback_.is_null());
 
@@ skipping 283 matching lines @@
 void AppCacheHost::LoadMainResourceCache(int64 cache_id) {
   DCHECK(cache_id != kNoCacheId);
   if (pending_main_resource_cache_id_ == cache_id ||
       (main_resource_cache_ && main_resource_cache_->cache_id() == cache_id)) {
     return;
   }
   pending_main_resource_cache_id_ = cache_id;
   service_->storage()->LoadCache(cache_id, this);
 }
 
-void AppCacheHost::NotifyMainResourceFallback(const GURL& fallback_url) {
-  main_resource_was_fallback_ = true;
-  fallback_url_ = fallback_url;
+void AppCacheHost::NotifyMainResourceIsNamespaceEntry(
+    const GURL& namespace_entry_url) {
+  main_resource_was_namespace_entry_ = true;
+  namespace_entry_url_ = namespace_entry_url;
 }
 
 void AppCacheHost::NotifyMainResourceBlocked(const GURL& manifest_url) {
   main_resource_blocked_ = true;
   blocked_manifest_url_ = manifest_url;
 }
 
 void AppCacheHost::AssociateNoCache(const GURL& manifest_url) {
   // manifest url can be empty.
   AssociateCacheHelper(NULL, manifest_url);
@@ skipping 22 matching lines @@
   associated_cache_info_pending_ = cache && !cache->is_complete();
   AppCacheInfo info;
   if (cache)
     cache->AssociateHost(this);
 
   FillCacheInfo(cache, manifest_url, GetStatus(), &info);
   frontend_->OnCacheSelected(host_id_, info);
 }
 
 }  // namespace appcache