Removing unused field - AppCacheResponseIO::group_id_.

content/browser/appcache/appcache_url_request_job_unittest.cc

 // Copyright 2014 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 <stdint.h>
 #include <string.h>
 
 #include <memory>
@@ skipping 484 matching lines @@
                                         base::Bind(&ExpectNotRestarted)));
     job->DeliverNetworkResponse();
     EXPECT_TRUE(job->is_delivering_network_response());
     EXPECT_FALSE(job->has_been_started());
 
     job.reset(new AppCacheURLRequestJob(request.get(), nullptr, storage,
                                         nullptr, false,
                                         base::Bind(&ExpectNotRestarted)));
     const GURL kManifestUrl("http://blah/");
     const int64_t kCacheId(1);
-    const int64_t kGroupId(1);
     const AppCacheEntry kEntry(AppCacheEntry::EXPLICIT, 1);
-    job->DeliverAppCachedResponse(kManifestUrl, kCacheId, kGroupId,
-                                  kEntry, false);
+    job->DeliverAppCachedResponse(kManifestUrl, kCacheId, kEntry, false);
     EXPECT_FALSE(job->is_waiting());
     EXPECT_TRUE(job->is_delivering_appcache_response());
     EXPECT_FALSE(job->has_been_started());
     EXPECT_EQ(kManifestUrl, job->manifest_url());
     EXPECT_EQ(kCacheId, job->cache_id());
-    EXPECT_EQ(kGroupId, job->group_id());
     EXPECT_EQ(kEntry.types(), job->entry().types());
     EXPECT_EQ(kEntry.response_id(), job->entry().response_id());
 
     TestFinished();
   }
 
   // DeliverNetworkResponse --------------------------------------------------
 
   void DeliverNetworkResponse() {
     // This test has async steps.
@@ skipping 77 matching lines @@
     // 2. Use net::URLRequest to retrieve it.
     // 3. Verify we received what we expected to receive.
 
     PushNextTask(base::Bind(
         &AppCacheURLRequestJobTest::VerifyDeliverSmallAppCachedResponse,
         base::Unretained(this)));
     PushNextTask(
         base::Bind(&AppCacheURLRequestJobTest::RequestAppCachedResource,
                    base::Unretained(this), false));
 
-    writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
+    writer_.reset(service_->storage()->CreateResponseWriter(GURL()));
     written_response_id_ = writer_->response_id();
     WriteBasicResponse();
     // Continues async
   }
 
   void RequestAppCachedResource(bool start_after_delivery_orders) {
     AppCacheStorage* storage = service_->storage();
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY,
                                              url_request_delegate_.get());
 
     // Setup to create an AppCacheURLRequestJob with orders to deliver
     // a network response.
     std::unique_ptr<AppCacheURLRequestJob> job(
         new AppCacheURLRequestJob(request_.get(), NULL, storage, NULL, false,
                                   base::Bind(&ExpectNotRestarted)));
 
     if (start_after_delivery_orders) {
       job->DeliverAppCachedResponse(
-          GURL(), 0, 111,
-          AppCacheEntry(AppCacheEntry::EXPLICIT, written_response_id_),
-          false);
+          GURL(), 111,
+          AppCacheEntry(AppCacheEntry::EXPLICIT, written_response_id_), false);
       EXPECT_TRUE(job->is_delivering_appcache_response());
     }
 
     // Start the request.
     EXPECT_FALSE(job->has_been_started());
     base::WeakPtr<AppCacheURLRequestJob> weak_job = job->GetWeakPtr();
     job_factory_->SetJob(std::move(job));
     request_->Start();
     EXPECT_FALSE(job_factory_->has_job());
     ASSERT_TRUE(weak_job);
     EXPECT_TRUE(weak_job->has_been_started());
 
     if (!start_after_delivery_orders) {
       weak_job->DeliverAppCachedResponse(
-          GURL(), 0, 111,
+          GURL(), 111,
           AppCacheEntry(AppCacheEntry::EXPLICIT, written_response_id_), false);
       ASSERT_TRUE(weak_job);
       EXPECT_TRUE(weak_job->is_delivering_appcache_response());
     }
 
     // Completion is async.
   }
 
   void VerifyDeliverSmallAppCachedResponse() {
     EXPECT_TRUE(request_->status().is_success());
@@ skipping 16 matching lines @@
     // 2. Use net::URLRequest to retrieve it.
     // 3. Verify we received what we expected to receive.
 
     PushNextTask(base::Bind(
        &AppCacheURLRequestJobTest::VerifyDeliverLargeAppCachedResponse,
        base::Unretained(this)));
     PushNextTask(base::Bind(
        &AppCacheURLRequestJobTest::RequestAppCachedResource,
        base::Unretained(this), true));
 
-    writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
+    writer_.reset(service_->storage()->CreateResponseWriter(GURL()));
     written_response_id_ = writer_->response_id();
     WriteLargeResponse();
     // Continues async
   }
 
   void WriteLargeResponse() {
     // 3, 1k blocks
     static const char kHttpHeaders[] =
         "HTTP/1.0 200 OK\0Content-Length: 3072\0\0";
     scoped_refptr<IOBuffer> body(new IOBuffer(kBlockSize * 3));
@@ skipping 22 matching lines @@
   void DeliverPartialResponse() {
     // This test has several async steps.
     // 1. Write a small response to response storage.
     // 2. Use net::URLRequest to retrieve it a subset using a range request
     // 3. Verify we received what we expected to receive.
     PushNextTask(base::Bind(
        &AppCacheURLRequestJobTest::VerifyDeliverPartialResponse,
        base::Unretained(this)));
     PushNextTask(base::Bind(
        &AppCacheURLRequestJobTest::MakeRangeRequest, base::Unretained(this)));
-    writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
+    writer_.reset(service_->storage()->CreateResponseWriter(GURL()));
     written_response_id_ = writer_->response_id();
     WriteBasicResponse();
     // Continues async
   }
 
   void MakeRangeRequest() {
     AppCacheStorage* storage = service_->storage();
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY,
                                              url_request_delegate_.get());
 
     // Request a range, the 3 middle chars out of 'Hello'
     net::HttpRequestHeaders extra_headers;
     extra_headers.SetHeader("Range", "bytes= 1-3");
     request_->SetExtraRequestHeaders(extra_headers);
 
     // Create job with orders to deliver an appcached entry.
     std::unique_ptr<AppCacheURLRequestJob> job(
         new AppCacheURLRequestJob(request_.get(), NULL, storage, NULL, false,
                                   base::Bind(&ExpectNotRestarted)));
     job->DeliverAppCachedResponse(
-        GURL(), 0, 111,
-        AppCacheEntry(AppCacheEntry::EXPLICIT, written_response_id_),
-        false);
+        GURL(), 111,
+        AppCacheEntry(AppCacheEntry::EXPLICIT, written_response_id_), false);
     EXPECT_TRUE(job->is_delivering_appcache_response());
 
     // Start the request.
     EXPECT_FALSE(job->has_been_started());
     job_factory_->SetJob(std::move(job));
     request_->Start();
     EXPECT_FALSE(job_factory_->has_job());
     // Completion is async.
   }
 
@@ skipping 23 matching lines @@
     // 1. Write a large response to response storage.
     // 2. Use net::URLRequest to retrieve it.
     // 3. Cancel the request after data starts coming in.
 
     PushNextTask(base::Bind(
        &AppCacheURLRequestJobTest::VerifyCancel, base::Unretained(this)));
     PushNextTask(base::Bind(
        &AppCacheURLRequestJobTest::RequestAppCachedResource,
        base::Unretained(this), true));
 
-    writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
+    writer_.reset(service_->storage()->CreateResponseWriter(GURL()));
     written_response_id_ = writer_->response_id();
     WriteLargeResponse();
 
     url_request_delegate_->kill_after_amount_received_ = kBlockSize;
     url_request_delegate_->kill_with_io_pending_ = false;
     // Continues async
   }
 
   void VerifyCancel() {
     EXPECT_EQ(net::URLRequestStatus::CANCELED,
               request_->status().status());
     TestFinished();
   }
 
   // CancelRequestWithIOPending --------------------------------------
 
   void CancelRequestWithIOPending() {
     // This test has several async steps.
     // 1. Write a large response to response storage.
     // 2. Use net::URLRequest to retrieve it.
     // 3. Cancel the request after data starts coming in.
 
     PushNextTask(base::Bind(
        &AppCacheURLRequestJobTest::VerifyCancel, base::Unretained(this)));
     PushNextTask(base::Bind(
        &AppCacheURLRequestJobTest::RequestAppCachedResource,
        base::Unretained(this), true));
 
-    writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
+    writer_.reset(service_->storage()->CreateResponseWriter(GURL()));
     written_response_id_ = writer_->response_id();
     WriteLargeResponse();
 
     url_request_delegate_->kill_after_amount_received_ = kBlockSize;
     url_request_delegate_->kill_with_io_pending_ = true;
     // Continues async
   }
 
 
   // Data members --------------------------------------------------------
@@ skipping 59 matching lines @@
 
 TEST_F(AppCacheURLRequestJobTest, CancelRequest) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::CancelRequest);
 }
 
 TEST_F(AppCacheURLRequestJobTest, CancelRequestWithIOPending) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::CancelRequestWithIOPending);
 }
 
 }  // namespace content