More groundwork for flat file based response storage.

webkit/appcache/appcache_response_unittest.cc

 // Copyright (c) 2010 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 <stack>
 #include <string>
 #include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/pickle.h"
@@ skipping 288 matching lines @@
   // 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(), kNoSuchResponseId));
+        GURL(), 0, kNoSuchResponseId));
 
     // Push tasks in reverse order
     PushNextTask(NewRunnableMethod(
        this, &AppCacheResponseTest::ReadNonExistentData));
     PushNextTask(NewRunnableMethod(
        this, &AppCacheResponseTest::ReadNonExistentInfo));
     ScheduleNextTask();
   }
 
   void ReadNonExistentInfo() {
     EXPECT_FALSE(reader_->IsReadPending());
     read_info_buffer_ = new HttpResponseInfoIOBuffer();
     reader_->ReadInfo(read_info_buffer_, &read_info_callback_);
     EXPECT_TRUE(reader_->IsReadPending());
     expected_read_result_ = net::ERR_CACHE_MISS;
   }
 
   void ReadNonExistentData() {
     EXPECT_FALSE(reader_->IsReadPending());
     read_buffer_ = new IOBuffer(kBlockSize);
     reader_->ReadData(read_buffer_, kBlockSize, &read_callback_);
     EXPECT_TRUE(reader_->IsReadPending());
     expected_read_result_ = net::ERR_CACHE_MISS;
   }
 
   // LoadResponseInfo_Miss ----------------------------------------------------
   void LoadResponseInfo_Miss() {
     PushNextTask(NewRunnableMethod(
         this, &AppCacheResponseTest::LoadResponseInfo_Miss_Verify));
-    service_->storage()->LoadResponseInfo(GURL(), kNoSuchResponseId,
+    service_->storage()->LoadResponseInfo(GURL(), 0, 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(NewRunnableMethod(
         this, &AppCacheResponseTest::LoadResponseInfo_Hit_Step2));
-    writer_.reset(service_->storage()->CreateResponseWriter(GURL()));
+    writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
     written_response_id_ = writer_->response_id();
     WriteBasicResponse();
   }
 
   void LoadResponseInfo_Hit_Step2() {
     writer_.reset();
     PushNextTask(NewRunnableMethod(
         this, &AppCacheResponseTest::LoadResponseInfo_Hit_Verify));
-    service_->storage()->LoadResponseInfo(GURL(), written_response_id_,
+    service_->storage()->LoadResponseInfo(GURL(), 0, 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 15 matching lines @@
     PushNextTask(NewRunnableMethod(
         this, &AppCacheResponseTest::Verify_AmountWritten,
         expected_amount_written));
     for (int i = 0; i < kNumBlocks; ++i) {
       PushNextTask(NewRunnableMethod(
           this, &AppCacheResponseTest::WriteOneBlock, kNumBlocks - i));
     }
     PushNextTask(NewRunnableMethod(
         this, &AppCacheResponseTest::WriteResponseHead, head));
 
-    writer_.reset(service_->storage()->CreateResponseWriter(GURL()));
+    writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
     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(NewRunnableMethod(
        this, &AppCacheResponseTest::ReadInBlocks));
     PushNextTask(NewRunnableMethod(
        this, &AppCacheResponseTest::WriteOutBlocks));
 
     // Get them going.
     ScheduleNextTask();
   }
 
   void WriteOutBlocks() {
-    writer_.reset(service_->storage()->CreateResponseWriter(GURL()));
+    writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
     written_response_id_ = writer_->response_id();
     for (int i = 0; i < kNumBlocks; ++i) {
       PushNextTask(NewRunnableMethod(
           this, &AppCacheResponseTest::WriteOneBlock, 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(), written_response_id_));
+        GURL(), 0, written_response_id_));
     for (int i = 0; i < kNumBlocks; ++i) {
       PushNextTask(NewRunnableMethod(
           this, &AppCacheResponseTest::ReadOneBlock, kNumBlocks - i));
     }
     ScheduleNextTask();
   }
 
   void ReadOneBlock(int block_number) {
     PushNextTask(NewRunnableMethod(
         this, &AppCacheResponseTest::VerifyOneBlock, 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(NewRunnableMethod(
         this, &AppCacheResponseTest::VerifyAllAtOnce));
     reader_.reset(service_->storage()->CreateResponseReader(
-        GURL(), written_response_id_));
+        GURL(), 0, 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_, kBlockSize, &read_callback_);
   }
 
   void ReadRange() {
     PushNextTask(NewRunnableMethod(
         this, &AppCacheResponseTest::VerifyRange));
     reader_.reset(service_->storage()->CreateResponseReader(
-        GURL(), written_response_id_));
+        GURL(), 0, 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(NewRunnableMethod(
         this, &AppCacheResponseTest::VerifyRangeBeyondEOF));
     reader_.reset(service_->storage()->CreateResponseReader(
-        GURL(), written_response_id_));
+        GURL(), 0, 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(), written_response_id_));
+        GURL(), 0, 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(NewRunnableMethod(
        this, &AppCacheResponseTest::ReadInBlocksImmediately));
     PushNextTaskAsImmediate(NewRunnableMethod(
        this, &AppCacheResponseTest::WriteOutBlocksImmediately));
 
     // Get them going.
     ScheduleNextTask();
   }
 
   void WriteOutBlocksImmediately() {
-    writer_.reset(service_->storage()->CreateResponseWriter(GURL()));
+    writer_.reset(service_->storage()->CreateResponseWriter(GURL(), 0));
     written_response_id_ = writer_->response_id();
     for (int i = 0; i < kNumBlocks; ++i) {
       PushNextTaskAsImmediate(NewRunnableMethod(
           this, &AppCacheResponseTest::WriteOneBlock, kNumBlocks - i));
     }
     ScheduleNextTask();
   }
 
   void ReadInBlocksImmediately() {
     writer_.reset();
     reader_.reset(service_->storage()->CreateResponseReader(
-        GURL(), written_response_id_));
+        GURL(), 0, written_response_id_));
     for (int i = 0; i < kNumBlocks; ++i) {
       PushNextTaskAsImmediate(NewRunnableMethod(
           this, &AppCacheResponseTest::ReadOneBlockImmediately,
           kNumBlocks - i));
     }
     ScheduleNextTask();
   }
 
   void ReadOneBlockImmediately(int block_number) {
     PushNextTaskAsImmediate(NewRunnableMethod(
@@ skipping 38 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(), written_response_id_));
+        GURL(), 0, written_response_id_));
     ReadResponseBody(new IOBuffer(kBlockSize), kBlockSize);
     EXPECT_TRUE(reader_->IsReadPending());
     reader_.reset();
 
     // Wait a moment to verify no callbacks.
     MessageLoop::current()->PostDelayedTask(FROM_HERE,
         NewRunnableMethod(this, &AppCacheResponseTest::VerifyNoCallbacks),
         10);
   }
 
@@ skipping 67 matching lines @@
 
 TEST_F(AppCacheResponseTest, DeleteWithIOPending) {
   RunTestOnIOThread(&AppCacheResponseTest::DeleteWithIOPending);
 }
 
 }  // namespace appcache
 
 // AppCacheResponseTest is expected to always live longer than the
 // runnable methods.  This lets us call NewRunnableMethod on its instances.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(appcache::AppCacheResponseTest);