Removing unused field - AppCacheResponseIO::group_id_.

content/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 "content/browser/appcache/appcache_request_handler.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "content/browser/appcache/appcache.h"
@@ skipping 100 matching lines @@
   if (request->url().GetOrigin() == location.GetOrigin())
     return NULL;
 
   DCHECK(!job_.get());  // our jobs never generate redirects
 
   std::unique_ptr<AppCacheURLRequestJob> job;
   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 = CreateJob(request, network_delegate);
-    DeliverAppCachedResponse(
-        found_fallback_entry_, found_cache_id_, found_group_id_,
-        found_manifest_url_,  true, found_namespace_entry_url_);
+    DeliverAppCachedResponse(found_fallback_entry_, found_cache_id_,
+                             found_manifest_url_, true,
+                             found_namespace_entry_url_);
   } else if (!found_network_namespace_) {
     // 6.9.6, step 6: Fail the resource load.
     job = CreateJob(request, network_delegate);
     DeliverErrorResponse();
   } else {
     // 6.9.6 step 3 and 5: Fetch the resource normally.
   }
 
   return job.release();
 }
@@ skipping 31 matching lines @@
     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.
   std::unique_ptr<AppCacheURLRequestJob> job =
       CreateJob(request, network_delegate);
-  DeliverAppCachedResponse(
-      found_fallback_entry_, found_cache_id_, found_group_id_,
-      found_manifest_url_, true, found_namespace_entry_url_);
+  DeliverAppCachedResponse(found_fallback_entry_, found_cache_id_,
+                           found_manifest_url_, true,
+                           found_namespace_entry_url_);
   return job.release();
 }
 
 void AppCacheRequestHandler::GetExtraResponseInfo(int64_t* cache_id,
                                                   GURL* manifest_url) {
   *cache_id = cache_id_;
   *manifest_url = manifest_url_;
 }
 
 void AppCacheRequestHandler::PrepareForCrossSiteTransfer(int old_process_id) {
@@ skipping 35 matching lines @@
   // that is current running. It's destined for the bit bucket anyway.
   if (job_.get()) {
     job_->Kill();
     job_.reset();
   }
 }
 
 void AppCacheRequestHandler::DeliverAppCachedResponse(
     const AppCacheEntry& entry,
     int64_t cache_id,
-    int64_t group_id,
     const GURL& manifest_url,
     bool is_fallback,
     const GURL& namespace_entry_url) {
   DCHECK(host_ && job_.get() && job_->is_waiting());
   DCHECK(entry.has_response_id());
 
   // Cache information about the response, for use by GetExtraResponseInfo.
   cache_id_ = cache_id;
   manifest_url_ = manifest_url;
 
   if (IsResourceTypeFrame(resource_type_) && !namespace_entry_url.is_empty())
     host_->NotifyMainResourceIsNamespaceEntry(namespace_entry_url);
 
-  job_->DeliverAppCachedResponse(manifest_url, group_id, cache_id,
-                                 entry, is_fallback);
+  job_->DeliverAppCachedResponse(manifest_url, cache_id, entry, is_fallback);
 }
 
 void AppCacheRequestHandler::DeliverErrorResponse() {
   DCHECK(job_.get() && job_->is_waiting());
   DCHECK_EQ(kAppCacheNoCacheId, cache_id_);
   DCHECK(manifest_url_.is_empty());
   job_->DeliverErrorResponse();
 }
 
 void AppCacheRequestHandler::DeliverNetworkResponse() {
@@ skipping 119 matching lines @@
   found_entry_ = entry;
   found_namespace_entry_url_ = namespace_entry_url;
   found_fallback_entry_ = fallback_entry;
   found_cache_id_ = cache_id;
   found_group_id_ = group_id;
   found_manifest_url_ = manifest_url;
   found_network_namespace_ = false;  // not applicable to main requests
 
   if (found_entry_.has_response_id()) {
     DCHECK(!found_fallback_entry_.has_response_id());
-    DeliverAppCachedResponse(
-        found_entry_, found_cache_id_, found_group_id_, found_manifest_url_,
-        false, found_namespace_entry_url_);
+    DeliverAppCachedResponse(found_entry_, found_cache_id_, found_manifest_url_,
+                             false, found_namespace_entry_url_);
   } else {
     DeliverNetworkResponse();
   }
 }
 
 // Sub-resource handling ----------------------------------------------
 
 std::unique_ptr<AppCacheURLRequestJob>
 AppCacheRequestHandler::MaybeLoadSubResource(
     net::URLRequest* request,
@@ skipping 32 matching lines @@
       host_->associated_cache(), url,
       &found_entry_, &found_fallback_entry_, &found_network_namespace_);
 
   if (found_entry_.has_response_id()) {
     // Step 2: If there's an entry, get it instead.
     DCHECK(!found_network_namespace_ &&
            !found_fallback_entry_.has_response_id());
     found_cache_id_ = cache->cache_id();
     found_group_id_ = cache->owning_group()->group_id();
     found_manifest_url_ = cache->owning_group()->manifest_url();
-    DeliverAppCachedResponse(
-        found_entry_, found_cache_id_, found_group_id_, found_manifest_url_,
-        false, GURL());
+    DeliverAppCachedResponse(found_entry_, found_cache_id_, found_manifest_url_,
+                             false, GURL());
     return;
   }
 
   if (found_fallback_entry_.has_response_id()) {
     // Step 4: Fetch the resource normally, if this results
     // in certain conditions, then use the fallback.
     DCHECK(!found_network_namespace_ &&
            !found_entry_.has_response_id());
     found_cache_id_ = cache->cache_id();
     found_manifest_url_ = cache->owning_group()->manifest_url();
@@ skipping 31 matching lines @@
   if (!host_->associated_cache() ||
       !host_->associated_cache()->is_complete()) {
     DeliverNetworkResponse();
     return;
   }
 
   ContinueMaybeLoadSubResource();
 }
 
 }  // namespace content