Check for supported schemes and methods.

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 "base/string_util.h"
 #include "webkit/api/public/WebURL.h"
 #include "webkit/api/public/WebURLRequest.h"
 #include "webkit/api/public/WebURLResponse.h"
 
 using WebKit::WebApplicationCacheHost;
 using WebKit::WebApplicationCacheHostClient;
 using WebKit::WebURLRequest;
 using WebKit::WebURL;
 using WebKit::WebURLResponse;
 
 namespace appcache {
 
 static IDMap<WebApplicationCacheHostImpl> all_hosts;
 
 WebApplicationCacheHostImpl* WebApplicationCacheHostImpl::FromId(int id) {
   return all_hosts.Lookup(id);
 }
 
 WebApplicationCacheHostImpl::WebApplicationCacheHostImpl(
     WebApplicationCacheHostClient* client,
     AppCacheBackend* backend)
     : client_(client),
       backend_(backend),
       ALLOW_THIS_IN_INITIALIZER_LIST(host_id_(all_hosts.Add(this))),
       has_status_(false),
       status_(UNCACHED),
       has_cached_status_(false),
       cached_status_(UNCACHED),
-      is_in_http_family_(false),
-      should_capture_main_response_(MAYBE) {
+      is_scheme_supported_(false),
+      is_get_method_(false),
+      is_new_master_entry_(MAYBE) {
   DCHECK(client && backend && (host_id_ != kNoHostId));
 
   backend_->RegisterHost(host_id_);
 }
 
 WebApplicationCacheHostImpl::~WebApplicationCacheHostImpl() {
   backend_->UnregisterHost(host_id_);
   all_hosts.Remove(host_id_);
 }
 
 void WebApplicationCacheHostImpl::OnCacheSelected(int64 selected_cache_id,
                                                   appcache::Status status) {
   status_ = status;
   has_status_ = true;
 }
 
 void WebApplicationCacheHostImpl::OnStatusChanged(appcache::Status status) {
   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.setAppCacheHostID(host_id_);
+  std::string method = request.httpMethod().utf8();
+  is_get_method_ = (method == kHttpGETMethod);
+  DCHECK(method == StringToUpperASCII(method));
 }
 
 void WebApplicationCacheHostImpl::willStartSubResourceRequest(
     WebURLRequest& request) {
   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(),
+  is_new_master_entry_ = NO;
+  backend_->SelectCache(host_id_, document_url_,
+                        document_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);
   }
 
+  // 6.9.6 The application cache selection algorithm
   // 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_,
+  if (document_response_.appCacheID() == kNoCacheId) {
+    if (is_scheme_supported_ && is_get_method_ &&
+        (manifest_gurl.GetOrigin() == document_url_.GetOrigin())) {
+      is_new_master_entry_ = YES;
+    } else {
+      is_new_master_entry_ = NO;
+      manifest_gurl = GURL::EmptyGURL();
+    }
+    backend_->SelectCache(host_id_, document_url_,
                           kNoCacheId, manifest_gurl);
     return true;
   }
 
-  DCHECK(should_capture_main_response_ == NO);
+  DCHECK(is_new_master_entry_ = NO);
 
+  // 6.9.6 The application cache selection algorithm
   // Check for 'foreign' entries.
-  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());
+  GURL document_manifest_gurl(document_response_.appCacheManifestURL());
+  if (document_manifest_gurl != manifest_gurl) {
+    backend_->MarkAsForeignEntry(host_id_, document_url_,
+                                 document_response_.appCacheID());
     has_cached_status_ = true;
     cached_status_ = UNCACHED;
     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(),
+  backend_->SelectCache(host_id_, document_url_,
+                        document_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;
+  document_response_ = response;
+  document_url_ = document_response_.url();
+  is_scheme_supported_ =  IsSchemeSupported(document_url_);
+  if ((document_response_.appCacheID() != kNoCacheId) ||
+      !is_scheme_supported_ || !is_get_method_)
+    is_new_master_entry_ = NO;
 }
 
 void WebApplicationCacheHostImpl::didReceiveDataForMainResource(
     const char* data, int len) {
-  if (should_capture_main_response_ == NO)
+  if (is_new_master_entry_ == NO)
     return;
   // TODO(michaeln): write me
 }
 
 void WebApplicationCacheHostImpl::didFinishLoadingMainResource(bool success) {
-  if (should_capture_main_response_ == NO)
+  if (is_new_master_entry_ == 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
@@ skipping 19 matching lines @@
 
 bool WebApplicationCacheHostImpl::startUpdate() {
   return backend_->StartUpdate(host_id_);
 }
 
 bool WebApplicationCacheHostImpl::swapCache() {
   return backend_->SwapCache(host_id_);
 }
 
 }  // appcache namespace