Add appCacheManifestUrl data member to WebURLResponse, and use it to detect '...

webkit/appcache/web_application_cache_host_impl.cc

 // Copyright (c) 2006-2008 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/web_application_cache_host_impl.h"
 
 #include "base/compiler_specific.h"
 #include "base/id_map.h"
 #include "webkit/api/public/WebURL.h"
 #include "webkit/api/public/WebURLRequest.h"
@@ skipping 45 matching lines @@
   if (has_status_)
     status_ = status;
 }
 
 void WebApplicationCacheHostImpl::OnEventRaised(appcache::EventID event_id) {
   client_->notifyEventListener(static_cast<EventID>(event_id));
 }
 
 void WebApplicationCacheHostImpl::willStartMainResourceRequest(
     WebURLRequest& request) {
-  request.setAppCacheContextID(host_id_);
+  request.setAppCacheHostID(host_id_);
 }
 
 void WebApplicationCacheHostImpl::willStartSubResourceRequest(
     WebURLRequest& request) {
-  request.setAppCacheContextID(host_id_);
+  request.setAppCacheHostID(host_id_);
 }
 
 void WebApplicationCacheHostImpl::selectCacheWithoutManifest() {
   // Reset any previous status values we've received from the backend
   // since we're now selecting a new cache.
   has_status_ = false;
   has_cached_status_ = false;
   should_capture_main_response_ = NO;
   backend_->SelectCache(host_id_, main_response_url_,
                         main_response_.appCacheID(),
                         GURL());
 }
 
 bool WebApplicationCacheHostImpl::selectCacheWithManifest(
     const WebURL& manifest_url) {
   // Reset any previous status values we've received from the backend
   // since we're now selecting a new cache.
   has_status_ = false;
   has_cached_status_ = false;
 
+  GURL manifest_gurl(manifest_url);
+  if (manifest_gurl.has_ref()) {
+    GURL::Replacements replacements;
+    replacements.ClearRef();
+    manifest_gurl = manifest_gurl.ReplaceComponents(replacements);
+  }
+
   // Check for new 'master' entries.
   if (main_response_.appCacheID() == kNoCacheId) {
     should_capture_main_response_ = is_in_http_family_ ? YES : NO;
     backend_->SelectCache(host_id_, main_response_url_,
-                          kNoCacheId, manifest_url);
+                          kNoCacheId, manifest_gurl);
     return true;
   }
 
   // Check for 'foreign' entries.
-  // TODO(michaeln): add manifestUrl() accessor to WebURLResponse,
-  //                 for now we don't really detect 'foreign' entries.
-  // TODO(michaeln): put an == operator on WebURL?
-  GURL manifest_gurl(manifest_url);
-  GURL main_response_manifest_gurl(manifest_url);  // = mainResp.manifestUrl()
+  GURL main_response_manifest_gurl(main_response_.appCacheManifestURL());
   if (main_response_manifest_gurl != manifest_gurl) {
     backend_->MarkAsForeignEntry(host_id_, main_response_url_,
                                  main_response_.appCacheID());
     selectCacheWithoutManifest();
     return false;  // the navigation will be restarted
   }
 
   // Its a 'master' entry thats already in the cache.
   backend_->SelectCache(host_id_, main_response_url_,
                         main_response_.appCacheID(),
                         manifest_gurl);
   return true;
 }
 
 void WebApplicationCacheHostImpl::didReceiveResponseForMainResource(
     const WebURLResponse& response) {
   main_response_ = response;
   main_response_url_ = main_response_.url();
   is_in_http_family_ =  main_response_url_.SchemeIs("http") ||
                         main_response_url_.SchemeIs("https");
   if ((main_response_.appCacheID() != kNoCacheId) || !is_in_http_family_)
     should_capture_main_response_ = NO;
 }
 
 void WebApplicationCacheHostImpl::didReceiveDataForMainResource(
     const char* data, int len) {
+  if (should_capture_main_response_ == NO)
+    return;
   // TODO(michaeln): write me
 }
 
 void WebApplicationCacheHostImpl::didFinishLoadingMainResource(bool success) {
+  if (should_capture_main_response_ == NO)
+    return;
   // TODO(michaeln): write me
 }
 
 WebApplicationCacheHost::Status WebApplicationCacheHostImpl::status() {
   // We're careful about the status value to avoid race conditions.
   //
   // Generally the webappcachehost sends an async stream of messages to the
   // backend, and receives an asyncronous stream of events from the backend.
   // In the backend, all operations are serialized and as state changes
   // 'events' are streamed out to relevant parties. In particular the
@@ skipping 18 matching lines @@
 
 bool WebApplicationCacheHostImpl::startUpdate() {
   return backend_->StartUpdate(host_id_);
 }
 
 bool WebApplicationCacheHostImpl::swapCache() {
   return backend_->SwapCache(host_id_);
 }
 
 }  // appcache namespace