Removing unused field - AppCacheResponseIO::group_id_.

content/browser/appcache/appcache_response_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 <stdint.h>
 #include <string.h>
 
 #include <stack>
 #include <string>
 #include <utility>
@@ skipping 300 matching lines @@
   // Individual Tests ---------------------------------------------------------
   // Most of the individual tests involve multiple async steps. Each test
   // is delineated with a section header.
 
 
   // ReadNonExistentResponse -------------------------------------------
   void ReadNonExistentResponse() {
     // 1. Attempt to ReadInfo
     // 2. Attempt to ReadData
 
-    reader_.reset(service_->storage()->CreateResponseReader(
-        GURL(), 0, kNoSuchResponseId));
+    reader_.reset(
+        service_->storage()->CreateResponseReader(GURL(), kNoSuchResponseId));
 
     // Push tasks in reverse order
     PushNextTask(base::Bind(&AppCacheResponseTest::ReadNonExistentData,
                             base::Unretained(this)));
     PushNextTask(base::Bind(&AppCacheResponseTest::ReadNonExistentInfo,
                             base::Unretained(this)));
     ScheduleNextTask();
   }
 
   void ReadNonExistentInfo() {
@@ skipping 14 matching lines @@
                       base::Bind(&AppCacheResponseTest::OnReadComplete,
                                  base::Unretained(this)));
     EXPECT_TRUE(reader_->IsReadPending());
     expected_read_result_ = net::ERR_CACHE_MISS;
   }
 
   // LoadResponseInfo_Miss ----------------------------------------------------
   void LoadResponseInfo_Miss() {
     PushNextTask(base::Bind(&AppCacheResponseTest::LoadResponseInfo_Miss_Verify,
                             base::Unretained(this)));
-    service_->storage()->LoadResponseInfo(GURL(), 0, kNoSuchResponseId,
+    service_->storage()->LoadResponseInfo(GURL(), kNoSuchResponseId,
                                           storage_delegate_.get());
   }
 
   void LoadResponseInfo_Miss_Verify() {
     EXPECT_EQ(kNoSuchResponseId, storage_delegate_->loaded_info_id_);
     EXPECT_TRUE(!storage_delegate_->loaded_info_.get());
     TestFinished();
   }
 
   // LoadResponseInfo_Hit ----------------------------------------------------
   void LoadResponseInfo_Hit() {
     // This tests involves multiple async steps.
     // 1. Write a response headers and body to storage
     //   a. headers
     //   b. body
     // 2. Use LoadResponseInfo to read the response headers back out
     PushNextTask(base::Bind(&AppCacheResponseTest::LoadResponseInfo_Hit_Step2,
                             base::Unretained(this)));
-    writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
+    writer_.reset(service_->storage()->CreateResponseWriter(GURL()));
     written_response_id_ = writer_->response_id();
     WriteBasicResponse();
   }
 
   void LoadResponseInfo_Hit_Step2() {
     writer_.reset();
     PushNextTask(base::Bind(&AppCacheResponseTest::LoadResponseInfo_Hit_Verify,
                             base::Unretained(this)));
-    service_->storage()->LoadResponseInfo(GURL(), 0, written_response_id_,
+    service_->storage()->LoadResponseInfo(GURL(), written_response_id_,
                                           storage_delegate_.get());
   }
 
   void LoadResponseInfo_Hit_Verify() {
     EXPECT_EQ(written_response_id_, storage_delegate_->loaded_info_id_);
     EXPECT_TRUE(storage_delegate_->loaded_info_.get());
     EXPECT_TRUE(CompareHttpResponseInfos(
         write_info_buffer_->http_info.get(),
         storage_delegate_->loaded_info_->http_response_info()));
     EXPECT_EQ(basic_response_size(),
@@ skipping 28 matching lines @@
     PushNextTask(base::Bind(&AppCacheResponseTest::Metadata_WriteMetadata,
                             base::Unretained(this), "Second"));
     PushNextTask(base::Bind(&AppCacheResponseTest::Metadata_VerifyMetadata,
                             base::Unretained(this), "Metadata First"));
     PushNextTask(base::Bind(&AppCacheResponseTest::Metadata_LoadResponseInfo,
                             base::Unretained(this)));
     PushNextTask(base::Bind(&AppCacheResponseTest::Metadata_WriteMetadata,
                             base::Unretained(this), "Metadata First"));
     PushNextTask(base::Bind(&AppCacheResponseTest::Metadata_ResetWriter,
                             base::Unretained(this)));
-    writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
+    writer_.reset(service_->storage()->CreateResponseWriter(GURL()));
     written_response_id_ = writer_->response_id();
     WriteBasicResponse();
   }
 
   void Metadata_ResetWriter() {
     writer_.reset();
     ScheduleNextTask();
   }
 
   void Metadata_WriteMetadata(const char* metadata) {
     metadata_writer_.reset(service_->storage()->CreateResponseMetadataWriter(
-        0, written_response_id_));
+        written_response_id_));
     scoped_refptr<IOBuffer> buffer(new WrappedIOBuffer(metadata));
     WriteResponseMetadata(buffer.get(), strlen(metadata));
   }
 
   void Metadata_LoadResponseInfo() {
     metadata_writer_.reset();
     storage_delegate_.reset(new MockStorageDelegate(this));
-    service_->storage()->LoadResponseInfo(GURL(), 0, written_response_id_,
+    service_->storage()->LoadResponseInfo(GURL(), written_response_id_,
                                           storage_delegate_.get());
   }
 
   void Metadata_VerifyMetadata(const char* metadata) {
     EXPECT_EQ(written_response_id_, storage_delegate_->loaded_info_id_);
     EXPECT_TRUE(storage_delegate_->loaded_info_.get());
     const net::HttpResponseInfo* read_head =
         storage_delegate_->loaded_info_->http_response_info();
     EXPECT_TRUE(read_head);
     const int metadata_size = strlen(metadata);
@@ skipping 25 matching lines @@
     // Push tasks in reverse order.
     PushNextTask(base::Bind(&AppCacheResponseTest::Verify_AmountWritten,
                             base::Unretained(this), expected_amount_written));
     for (int i = 0; i < kNumBlocks; ++i) {
       PushNextTask(base::Bind(&AppCacheResponseTest::WriteOneBlock,
                               base::Unretained(this), kNumBlocks - i));
     }
     PushNextTask(base::Bind(&AppCacheResponseTest::WriteResponseHead,
                             base::Unretained(this), head));
 
-    writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
+    writer_.reset(service_->storage()->CreateResponseWriter(GURL()));
     written_response_id_ = writer_->response_id();
     ScheduleNextTask();
   }
 
   void Verify_AmountWritten(int expected_amount_written) {
     EXPECT_EQ(expected_amount_written, writer_->amount_written());
     TestFinished();
   }
 
 
@@ skipping 25 matching lines @@
     PushNextTask(base::Bind(&AppCacheResponseTest::ReadInBlocks,
                             base::Unretained(this)));
     PushNextTask(base::Bind(&AppCacheResponseTest::WriteOutBlocks,
                             base::Unretained(this)));
 
     // Get them going.
     ScheduleNextTask();
   }
 
   void WriteOutBlocks() {
-    writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
+    writer_.reset(service_->storage()->CreateResponseWriter(GURL()));
     written_response_id_ = writer_->response_id();
     for (int i = 0; i < kNumBlocks; ++i) {
       PushNextTask(base::Bind(&AppCacheResponseTest::WriteOneBlock,
                               base::Unretained(this), kNumBlocks - i));
     }
     ScheduleNextTask();
   }
 
   void WriteOneBlock(int block_number) {
     scoped_refptr<IOBuffer> io_buffer(
         new IOBuffer(kBlockSize));
     FillData(block_number, io_buffer->data(), kBlockSize);
     WriteResponseBody(io_buffer, kBlockSize);
   }
 
   void ReadInBlocks() {
     writer_.reset();
     reader_.reset(service_->storage()->CreateResponseReader(
-        GURL(), 0, written_response_id_));
+        GURL(), written_response_id_));
     for (int i = 0; i < kNumBlocks; ++i) {
       PushNextTask(base::Bind(&AppCacheResponseTest::ReadOneBlock,
                               base::Unretained(this), kNumBlocks - i));
     }
     ScheduleNextTask();
   }
 
   void ReadOneBlock(int block_number) {
     PushNextTask(base::Bind(&AppCacheResponseTest::VerifyOneBlock,
                             base::Unretained(this), block_number));
     ReadResponseBody(new IOBuffer(kBlockSize), kBlockSize);
   }
 
   void VerifyOneBlock(int block_number) {
     EXPECT_TRUE(CheckData(block_number, read_buffer_->data(), kBlockSize));
     ScheduleNextTask();
   }
 
   void ReadAllAtOnce() {
     PushNextTask(base::Bind(&AppCacheResponseTest::VerifyAllAtOnce,
                             base::Unretained(this)));
     reader_.reset(service_->storage()->CreateResponseReader(
-        GURL(), 0, written_response_id_));
+        GURL(), written_response_id_));
     int big_size = kNumBlocks * kBlockSize;
     ReadResponseBody(new IOBuffer(big_size), big_size);
   }
 
   void VerifyAllAtOnce() {
     char* p = read_buffer_->data();
     for (int i = 0; i < kNumBlocks; ++i, p += kBlockSize)
       EXPECT_TRUE(CheckData(i + 1, p, kBlockSize));
     ScheduleNextTask();
   }
 
   void ReadPastEOF() {
     EXPECT_FALSE(reader_->IsReadPending());
     read_buffer_ = new IOBuffer(kBlockSize);
     expected_read_result_ = 0;
     reader_->ReadData(read_buffer_.get(),
                       kBlockSize,
                       base::Bind(&AppCacheResponseTest::OnReadComplete,
                                  base::Unretained(this)));
   }
 
   void ReadRange() {
     PushNextTask(base::Bind(&AppCacheResponseTest::VerifyRange,
                             base::Unretained(this)));
     reader_.reset(service_->storage()->CreateResponseReader(
-        GURL(), 0, written_response_id_));
+        GURL(), written_response_id_));
     reader_->SetReadRange(kBlockSize, kBlockSize);
     ReadResponseBody(new IOBuffer(kBlockSize), kBlockSize);
   }
 
   void VerifyRange() {
     EXPECT_TRUE(CheckData(2, read_buffer_->data(), kBlockSize));
     ScheduleNextTask();  // ReadPastEOF is scheduled next
   }
 
   void ReadRangePartiallyBeyondEOF() {
     PushNextTask(base::Bind(&AppCacheResponseTest::VerifyRangeBeyondEOF,
                             base::Unretained(this)));
     reader_.reset(service_->storage()->CreateResponseReader(
-        GURL(), 0, written_response_id_));
+        GURL(), written_response_id_));
     reader_->SetReadRange(kBlockSize, kNumBlocks * kBlockSize);
     ReadResponseBody(new IOBuffer(kNumBlocks * kBlockSize),
                      kNumBlocks * kBlockSize);
     expected_read_result_ = (kNumBlocks - 1) * kBlockSize;
   }
 
   void VerifyRangeBeyondEOF() {
     // Just verify the first 1k
     VerifyRange();
   }
 
   void ReadRangeFullyBeyondEOF() {
     reader_.reset(service_->storage()->CreateResponseReader(
-        GURL(), 0, written_response_id_));
+        GURL(), written_response_id_));
     reader_->SetReadRange((kNumBlocks * kBlockSize) + 1, kBlockSize);
     ReadResponseBody(new IOBuffer(kBlockSize), kBlockSize);
     expected_read_result_ = 0;
   }
 
   // IOChaining -------------------------------------------
   void IOChaining() {
     // 1. Write several blocks out initiating the subsequent write
     //    from within the completion callback of the previous write.
     // 2. Read and verify several blocks in similarly chaining reads.
 
     // Push tasks in reverse order
     PushNextTaskAsImmediate(
         base::Bind(&AppCacheResponseTest::ReadInBlocksImmediately,
                    base::Unretained(this)));
     PushNextTaskAsImmediate(
         base::Bind(&AppCacheResponseTest::WriteOutBlocksImmediately,
                    base::Unretained(this)));
 
     // Get them going.
     ScheduleNextTask();
   }
 
   void WriteOutBlocksImmediately() {
-    writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
+    writer_.reset(service_->storage()->CreateResponseWriter(GURL()));
     written_response_id_ = writer_->response_id();
     for (int i = 0; i < kNumBlocks; ++i) {
       PushNextTaskAsImmediate(
           base::Bind(&AppCacheResponseTest::WriteOneBlock,
                      base::Unretained(this), kNumBlocks - i));
     }
     ScheduleNextTask();
   }
 
   void ReadInBlocksImmediately() {
     writer_.reset();
     reader_.reset(service_->storage()->CreateResponseReader(
-        GURL(), 0, written_response_id_));
+        GURL(), written_response_id_));
     for (int i = 0; i < kNumBlocks; ++i) {
       PushNextTaskAsImmediate(
           base::Bind(&AppCacheResponseTest::ReadOneBlockImmediately,
                      base::Unretained(this),
           kNumBlocks - i));
     }
     ScheduleNextTask();
   }
 
   void ReadOneBlockImmediately(int block_number) {
@@ skipping 39 matching lines @@
     write_callback_was_called_ = false;
     WriteOneBlock(5);
     EXPECT_TRUE(writer_->IsWritePending());
     writer_.reset();
     ScheduleNextTask();
   }
 
   void ReadThenDelete() {
     read_callback_was_called_ = false;
     reader_.reset(service_->storage()->CreateResponseReader(
-        GURL(), 0, written_response_id_));
+        GURL(), written_response_id_));
     ReadResponseBody(new IOBuffer(kBlockSize), kBlockSize);
     EXPECT_TRUE(reader_->IsReadPending());
     reader_.reset();
 
     // Wait a moment to verify no callbacks.
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, base::Bind(&AppCacheResponseTest::VerifyNoCallbacks,
                               base::Unretained(this)),
         base::TimeDelta::FromMilliseconds(10));
   }
@@ skipping 65 matching lines @@
 
 TEST_F(AppCacheResponseTest, DeleteWithinCallbacks) {
   RunTestOnIOThread(&AppCacheResponseTest::DeleteWithinCallbacks);
 }
 
 TEST_F(AppCacheResponseTest, DeleteWithIOPending) {
   RunTestOnIOThread(&AppCacheResponseTest::DeleteWithIOPending);
 }
 
 }  // namespace content