Removing unused field - AppCacheResponseIO::group_id_.

content/browser/appcache/appcache_url_request_job.cc

 // Copyright (c) 2012 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_url_request_job.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 23 matching lines @@
 AppCacheURLRequestJob::AppCacheURLRequestJob(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
     AppCacheStorage* storage,
     AppCacheHost* host,
     bool is_main_resource,
     const OnPrepareToRestartCallback& restart_callback)
     : net::URLRequestJob(request, network_delegate),
       host_(host),
       storage_(storage),
-      has_been_started_(false), has_been_killed_(false),
+      has_been_started_(false),
+      has_been_killed_(false),
       delivery_type_(AWAITING_DELIVERY_ORDERS),
-      group_id_(0), cache_id_(kAppCacheNoCacheId), is_fallback_(false),
+      cache_id_(kAppCacheNoCacheId),
+      is_fallback_(false),
       is_main_resource_(is_main_resource),
       cache_entry_not_found_(false),
       on_prepare_to_restart_callback_(restart_callback),
       weak_factory_(this) {
   DCHECK(storage_);
 }
 
 AppCacheURLRequestJob::~AppCacheURLRequestJob() {
   if (storage_)
     storage_->CancelDelegateCallbacks(this);
 }
 
 void AppCacheURLRequestJob::DeliverAppCachedResponse(const GURL& manifest_url,
-                                                     int64_t group_id,
                                                      int64_t cache_id,
                                                      const AppCacheEntry& entry,
                                                      bool is_fallback) {
   DCHECK(!has_delivery_orders());
   DCHECK(entry.has_response_id());
   delivery_type_ = APPCACHED_DELIVERY;
   manifest_url_ = manifest_url;
-  group_id_ = group_id;
   cache_id_ = cache_id;
   entry_ = entry;
   is_fallback_ = is_fallback;
   MaybeBeginDelivery();
 }
 
 void AppCacheURLRequestJob::DeliverNetworkResponse() {
   DCHECK(!has_delivery_orders());
   delivery_type_ = NETWORK_DELIVERY;
   storage_ = NULL;  // not needed
@@ skipping 51 matching lines @@
       if (entry_.IsExecutable()) {
         BeginExecutableHandlerDelivery();
         return;
       }
       AppCacheHistograms::AddAppCacheJobStartDelaySample(
           base::TimeTicks::Now() - start_time_tick_);
       request()->net_log().AddEvent(
           is_fallback_ ?
               net::NetLog::TYPE_APPCACHE_DELIVERING_FALLBACK_RESPONSE :
               net::NetLog::TYPE_APPCACHE_DELIVERING_CACHED_RESPONSE);
-      storage_->LoadResponseInfo(
-          manifest_url_, group_id_, entry_.response_id(), this);
+      storage_->LoadResponseInfo(manifest_url_, entry_.response_id(), this);
       break;
 
     default:
       NOTREACHED();
       break;
   }
 }
 
 void AppCacheURLRequestJob::BeginExecutableHandlerDelivery() {
   DCHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
@@ skipping 42 matching lines @@
   // NOTE: This is not ideal since multiple jobs may be doing this,
   // concurrently but close enough for now, the first to load the script
   // will win.
 
   // Read the script data, truncating if its too large.
   // NOTE: we just issue one read and don't bother chaining if the resource
   // is very (very) large, close enough for now.
   const int64_t kLimit = 500 * 1000;
   handler_source_buffer_ = new net::GrowableIOBuffer();
   handler_source_buffer_->SetCapacity(kLimit);
-  handler_source_reader_.reset(storage_->CreateResponseReader(
-      manifest_url_, group_id_, entry_.response_id()));
+  handler_source_reader_.reset(
+      storage_->CreateResponseReader(manifest_url_, entry_.response_id()));
   handler_source_reader_->ReadData(
       handler_source_buffer_.get(),
       kLimit,
       base::Bind(&AppCacheURLRequestJob::OnExecutableSourceLoaded,
                  base::Unretained(this)));
 }
 
 void AppCacheURLRequestJob::OnExecutableSourceLoaded(int result) {
   DCHECK(!has_been_killed());
   handler_source_reader_.reset();
@@ skipping 60 matching lines @@
   storage_ = NULL;
   BeginDelivery();
 }
 
 void AppCacheURLRequestJob::OnResponseInfoLoaded(
     AppCacheResponseInfo* response_info,
     int64_t response_id) {
   DCHECK(is_delivering_appcache_response());
   if (response_info) {
     info_ = response_info;
-    reader_.reset(storage_->CreateResponseReader(
-        manifest_url_, group_id_, entry_.response_id()));
+    reader_.reset(
+        storage_->CreateResponseReader(manifest_url_, entry_.response_id()));
 
     if (is_range_request())
       SetupRangeResponse();
 
     NotifyHeadersComplete();
   } else {
     if (storage_->service()->storage() == storage_) {
       // A resource that is expected to be in the appcache is missing.
       // See http://code.google.com/p/chromium/issues/detail?id=50657
       // Instead of failing the request, we restart the request. The retry
@@ skipping 155 matching lines @@
   if (ranges.size() == 1U)
     range_requested_ = ranges[0];
 }
 
 void AppCacheURLRequestJob::NotifyRestartRequired() {
   on_prepare_to_restart_callback_.Run();
   URLRequestJob::NotifyRestartRequired();
 }
 
 }  // namespace content