more uma stats

webkit/browser/appcache/appcache_request_handler.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/browser/appcache/appcache_request_handler.h"
 
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_job.h"
 #include "webkit/browser/appcache/appcache.h"
 #include "webkit/browser/appcache/appcache_backend_impl.h"
@@ skipping 85 matching lines @@
     return NULL;
   if (request->url().GetOrigin() == location.GetOrigin())
     return NULL;
 
   DCHECK(!job_.get());  // our jobs never generate redirects
 
   if (found_fallback_entry_.has_response_id()) {
     // 6.9.6, step 4: If this results in a redirect to another origin,
     // get the resource of the fallback entry.
     job_ = new AppCacheURLRequestJob(request, network_delegate,
-                                     storage(), host_);
+                                     storage(), host_, is_main_resource());
     DeliverAppCachedResponse(
         found_fallback_entry_, found_cache_id_, found_group_id_,
         found_manifest_url_,  true, found_namespace_entry_url_);
   } else if (!found_network_namespace_) {
     // 6.9.6, step 6: Fail the resource load.
     job_ = new AppCacheURLRequestJob(request, network_delegate,
-                                     storage(), host_);
+                                     storage(), host_, is_main_resource());
     DeliverErrorResponse();
   } else {
     // 6.9.6 step 3 and 5: Fetch the resource normally.
   }
 
   return job_.get();
 }
 
 AppCacheURLRequestJob* AppCacheRequestHandler::MaybeLoadFallbackForResponse(
     net::URLRequest* request, net::NetworkDelegate* network_delegate) {
@@ skipping 25 matching lines @@
         "disallow-fallback");
     std::string header_value;
     request->GetResponseHeaderByName(kFallbackOverrideHeader, &header_value);
     if (header_value == kFallbackOverrideValue)
       return NULL;
   }
 
   // 6.9.6, step 4: If this results in a 4xx or 5xx status code
   // or there were network errors, get the resource of the fallback entry.
   job_ = new AppCacheURLRequestJob(request, network_delegate,
-                                   storage(), host_);
+                                   storage(), host_, is_main_resource());
   DeliverAppCachedResponse(
       found_fallback_entry_, found_cache_id_, found_group_id_,
       found_manifest_url_, true, found_namespace_entry_url_);
   return job_.get();
 }
 
 void AppCacheRequestHandler::GetExtraResponseInfo(
     int64* cache_id, GURL* manifest_url) {
   if (job_.get() && job_->is_delivering_appcache_response()) {
     *cache_id = job_->cache_id();
@@ skipping 63 matching lines @@
 
   const AppCacheHost* spawning_host =
       ResourceType::IsSharedWorker(resource_type_) ?
           host_ : host_->GetSpawningHost();
   GURL preferred_manifest_url = spawning_host ?
       spawning_host->preferred_manifest_url() : GURL();
 
   // We may have to wait for our storage query to complete, but
   // this query can also complete syncrhonously.
   job_ = new AppCacheURLRequestJob(request, network_delegate,
-                                   storage(), host_);
+                                   storage(), host_, is_main_resource());
   storage()->FindResponseForMainRequest(
       request->url(), preferred_manifest_url, this);
 }
 
 void AppCacheRequestHandler::OnMainResponseFound(
     const GURL& url, const AppCacheEntry& entry,
     const GURL& namespace_entry_url, const AppCacheEntry& fallback_entry,
     int64 cache_id, int64 group_id, const GURL& manifest_url) {
   DCHECK(job_.get());
   DCHECK(host_);
@@ skipping 53 matching lines @@
 
 void AppCacheRequestHandler::MaybeLoadSubResource(
     net::URLRequest* request, net::NetworkDelegate* network_delegate) {
   DCHECK(!job_.get());
 
   if (host_->is_selection_pending()) {
     // We have to wait until cache selection is complete and the
     // selected cache is loaded.
     is_waiting_for_cache_selection_ = true;
     job_ = new AppCacheURLRequestJob(request, network_delegate,
-                                     storage(), host_);
+                                     storage(), host_, is_main_resource());
     return;
   }
 
   if (!host_->associated_cache() ||
-      !host_->associated_cache()->is_complete()) {
+      !host_->associated_cache()->is_complete() ||
+      host_->associated_cache()->owning_group()->is_being_deleted()) {

[jsbell, 2014/03/21 16:41:02]

Is this a behavior change?

[michaeln, 2014/03/24 18:12:04]

Yes, when is_being_deleted the request is doomed to fail, so the early bailout
is to avoid those being counted as failures in CountResponseRetrieval.

     return;
   }
 
   job_ = new AppCacheURLRequestJob(request, network_delegate,
-                                   storage(), host_);
+                                   storage(), host_, is_main_resource());
   ContinueMaybeLoadSubResource();
 }
 
 void AppCacheRequestHandler::ContinueMaybeLoadSubResource() {
   // 6.9.6 Changes to the networking model
   // If the resource is not to be fetched using the HTTP GET mechanism or
   // equivalent ... then fetch the resource normally.
   DCHECK(job_.get());
   DCHECK(host_->associated_cache() && host_->associated_cache()->is_complete());
 
@@ skipping 51 matching lines @@
   if (!host_->associated_cache() ||
       !host_->associated_cache()->is_complete()) {
     DeliverNetworkResponse();
     return;
   }
 
   ContinueMaybeLoadSubResource();
 }
 
 }  // namespace appcache