Introduce AppCacheResponseMetadataWriter to support metadata caching.

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 <stack>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 173 matching lines @@
   void WriteResponseBody(scoped_refptr<IOBuffer> io_buffer, int buf_len) {
     EXPECT_FALSE(writer_->IsWritePending());
     write_buffer_ = io_buffer;
     expected_write_result_ = buf_len;
     writer_->WriteData(write_buffer_.get(),
                        buf_len,
                        base::Bind(&AppCacheResponseTest::OnWriteComplete,
                                   base::Unretained(this)));
   }
 
+  void WriteResponseMetadata(scoped_refptr<IOBuffer> io_buffer, int buf_len) {
+    EXPECT_FALSE(metadata_writer_->IsWritePending());
+    write_buffer_ = io_buffer;
+    expected_write_result_ = buf_len;
+    metadata_writer_->WriteMetadata(
+        write_buffer_.get(), buf_len,
+        base::Bind(&AppCacheResponseTest::OnMetadataWriteComplete,
+                   base::Unretained(this)));
+  }
+
   void ReadResponseBody(scoped_refptr<IOBuffer> io_buffer, int buf_len) {
     EXPECT_FALSE(reader_->IsReadPending());
     read_buffer_ = io_buffer;
     expected_read_result_ = buf_len;
     reader_->ReadData(read_buffer_.get(),
                       buf_len,
                       base::Bind(&AppCacheResponseTest::OnReadComplete,
                                  base::Unretained(this)));
   }
 
   // AppCacheResponseReader / Writer completion callbacks
 
   void OnWriteInfoComplete(int result) {
     EXPECT_FALSE(writer_->IsWritePending());
     EXPECT_EQ(expected_write_result_, result);
     ScheduleNextTask();
   }
 
   void OnWriteComplete(int result) {
     EXPECT_FALSE(writer_->IsWritePending());
     write_callback_was_called_ = true;
     EXPECT_EQ(expected_write_result_, result);
     if (should_delete_writer_in_completion_callback_ &&
         --writer_deletion_count_down_ == 0) {
       writer_.reset();
     }
     ScheduleNextTask();
   }
 
+  void OnMetadataWriteComplete(int result) {
+    EXPECT_FALSE(metadata_writer_->IsWritePending());
+    EXPECT_EQ(expected_write_result_, result);
+    ScheduleNextTask();
+  }
+
   void OnReadInfoComplete(int result) {
     EXPECT_FALSE(reader_->IsReadPending());
     EXPECT_EQ(expected_read_result_, result);
     ScheduleNextTask();
   }
 
   void OnReadComplete(int result) {
     EXPECT_FALSE(reader_->IsReadPending());
     read_callback_was_called_ = true;
     EXPECT_EQ(expected_read_result_, result);
@@ skipping 133 matching lines @@
     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(),
               storage_delegate_->loaded_info_->response_data_size());
     TestFinished();
   }
 
+  // Metadata -------------------------------------------------
+  void Metadata() {
+    // This tests involves multiple async steps.
+    // 1. Write a response headers and body to storage
+    //   a. headers
+    //   b. body
+    // 2. Write metadata "Metadata First" using AppCacheResponseMetadataWriter.
+    // 3. Check metadata was written.
+    // 4. Write metadata "Second".
+    // 5. Check metadata was written and was truncated .
+    // 6. Write metadata "".
+    // 7. Check metadata was deleted.
+
+    // Push tasks in reverse order.
+    PushNextTask(base::Bind(&AppCacheResponseTest::Metadata_VerifyMetadata,
+                            base::Unretained(this), ""));
+    PushNextTask(base::Bind(&AppCacheResponseTest::Metadata_LoadResponseInfo,
+                            base::Unretained(this)));
+    PushNextTask(base::Bind(&AppCacheResponseTest::Metadata_WriteMetadata,
+                            base::Unretained(this), ""));
+    PushNextTask(base::Bind(&AppCacheResponseTest::Metadata_VerifyMetadata,
+                            base::Unretained(this), "Second"));
+    PushNextTask(base::Bind(&AppCacheResponseTest::Metadata_LoadResponseInfo,
+                            base::Unretained(this)));
+    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));
+    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_));
+    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_,
+                                          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);
+    if (metadata_size) {
+      EXPECT_TRUE(read_head->metadata.get());
+      EXPECT_EQ(metadata_size, read_head->metadata->size());
+      EXPECT_EQ(0,
+                memcmp(metadata, read_head->metadata->data(), metadata_size));
+    } else {
+      EXPECT_FALSE(read_head->metadata.get());
+    }
+    EXPECT_TRUE(CompareHttpResponseInfos(
+        write_info_buffer_->http_info.get(),
+        storage_delegate_->loaded_info_->http_response_info()));
+    EXPECT_EQ(basic_response_size(),
+              storage_delegate_->loaded_info_->response_data_size());
+    ScheduleNextTask();
+  }
+
   // AmountWritten ----------------------------------------------------
 
   void AmountWritten() {
     static const char kHttpHeaders[] = "HTTP/1.0 200 OK\0\0";
     std::string raw_headers(kHttpHeaders, arraysize(kHttpHeaders));
     net::HttpResponseInfo* head = MakeHttpResponseInfo(raw_headers);
     int expected_amount_written =
         GetHttpResponseInfoSize(head) + kNumBlocks * kBlockSize;
 
     // Push tasks in reverse order.
@@ skipping 274 matching lines @@
   scoped_ptr<AppCacheResponseReader> reader_;
   scoped_refptr<HttpResponseInfoIOBuffer> read_info_buffer_;
   scoped_refptr<IOBuffer> read_buffer_;
   int expected_read_result_;
   bool should_delete_reader_in_completion_callback_;
   int reader_deletion_count_down_;
   bool read_callback_was_called_;
 
   int64 written_response_id_;
   scoped_ptr<AppCacheResponseWriter> writer_;
+  scoped_ptr<AppCacheResponseMetadataWriter> metadata_writer_;
   scoped_refptr<HttpResponseInfoIOBuffer> write_info_buffer_;
   scoped_refptr<IOBuffer> write_buffer_;
   int expected_write_result_;
   bool should_delete_writer_in_completion_callback_;
   int writer_deletion_count_down_;
   bool write_callback_was_called_;
 
   static scoped_ptr<base::Thread> io_thread_;
 };
 
 // static
 scoped_ptr<base::Thread> AppCacheResponseTest::io_thread_;
 
 TEST_F(AppCacheResponseTest, ReadNonExistentResponse) {
   RunTestOnIOThread(&AppCacheResponseTest::ReadNonExistentResponse);
 }
 
 TEST_F(AppCacheResponseTest, LoadResponseInfo_Miss) {
   RunTestOnIOThread(&AppCacheResponseTest::LoadResponseInfo_Miss);
 }
 
 TEST_F(AppCacheResponseTest, LoadResponseInfo_Hit) {
   RunTestOnIOThread(&AppCacheResponseTest::LoadResponseInfo_Hit);
 }
 
+TEST_F(AppCacheResponseTest, Metadata) {
+  RunTestOnIOThread(&AppCacheResponseTest::Metadata);
+}
+
 TEST_F(AppCacheResponseTest, AmountWritten) {
   RunTestOnIOThread(&AppCacheResponseTest::AmountWritten);
 }
 
 TEST_F(AppCacheResponseTest, WriteThenVariouslyReadResponse) {
   RunTestOnIOThread(&AppCacheResponseTest::WriteThenVariouslyReadResponse);
 }
 
 TEST_F(AppCacheResponseTest, IOChaining) {
   RunTestOnIOThread(&AppCacheResponseTest::IOChaining);
 }
 
 TEST_F(AppCacheResponseTest, DeleteWithinCallbacks) {
   RunTestOnIOThread(&AppCacheResponseTest::DeleteWithinCallbacks);
 }
 
 TEST_F(AppCacheResponseTest, DeleteWithIOPending) {
   RunTestOnIOThread(&AppCacheResponseTest::DeleteWithIOPending);
 }
 
 }  // namespace content