Introduce AppCacheResponseMetadataWriter to support metadata caching.

content/browser/appcache/appcache_response.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_response.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/pickle.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_util.h"
 #include "content/browser/appcache/appcache_storage.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 
 namespace content {
 
 namespace {
 
 // Disk cache entry data indices.
-enum {
-  kResponseInfoIndex,
-  kResponseContentIndex
-};
+enum { kResponseInfoIndex, kResponseContentIndex, kResponseMetadataIndex };
 
 // An IOBuffer that wraps a pickle's data. Ownership of the
 // pickle is transfered to the WrappedPickleIOBuffer object.
 class WrappedPickleIOBuffer : public net::WrappedIOBuffer {
  public:
   explicit WrappedPickleIOBuffer(const Pickle* pickle) :
       net::WrappedIOBuffer(reinterpret_cast<const char*>(pickle->data())),
       pickle_(pickle) {
     DCHECK(pickle->data());
   }
@@ skipping 93 matching lines @@
 void AppCacheResponseIO::OnRawIOComplete(int result) {
   // TODO(vadimt): Remove ScopedTracker below once crbug.com/422516 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "422516 AppCacheResponseIO::OnRawIOComplete"));
 
   DCHECK_NE(net::ERR_IO_PENDING, result);
   OnIOComplete(result);
 }
 
+void AppCacheResponseIO::OpenEntryIfNeeded() {
+  int rv;
+  AppCacheDiskCacheInterface::Entry** entry_ptr = NULL;
+  if (entry_) {
+    rv = net::OK;
+  } else if (!disk_cache_) {
+    rv = net::ERR_FAILED;
+  } else {
+    entry_ptr = new AppCacheDiskCacheInterface::Entry*;
+    open_callback_ =
+        base::Bind(&AppCacheResponseIO::OpenEntryCallback,
+                   weak_factory_.GetWeakPtr(), base::Owned(entry_ptr));
+    rv = disk_cache_->OpenEntry(response_id_, entry_ptr, open_callback_);
+  }
+
+  if (rv != net::ERR_IO_PENDING)
+    OpenEntryCallback(entry_ptr, rv);
+}
+
+void AppCacheResponseIO::OpenEntryCallback(
+    AppCacheDiskCacheInterface::Entry** entry, int rv) {
+  DCHECK(info_buffer_.get() || buffer_.get());
+
+  if (!open_callback_.is_null()) {
+    if (rv == net::OK) {
+      DCHECK(entry);
+      entry_ = *entry;
+    }
+    open_callback_.Reset();
+  }
+  OnOpenEntryComplete();
+}
+
 
 // AppCacheResponseReader ----------------------------------------------
 
 AppCacheResponseReader::AppCacheResponseReader(
-    int64 response_id, int64 group_id, AppCacheDiskCacheInterface* disk_cache)
+    int64 response_id,
+    int64 group_id,
+    AppCacheDiskCacheInterface* disk_cache)
     : AppCacheResponseIO(response_id, group_id, disk_cache),
       range_offset_(0),
       range_length_(kint32max),
       read_position_(0),
+      reading_metadata_size_(0),
       weak_factory_(this) {
 }
 
 AppCacheResponseReader::~AppCacheResponseReader() {
 }
 
 void AppCacheResponseReader::ReadInfo(HttpResponseInfoIOBuffer* info_buf,
                                       const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   DCHECK(!IsReadPending());
   DCHECK(info_buf);
   DCHECK(!info_buf->http_info.get());
   DCHECK(!buffer_.get());
   DCHECK(!info_buffer_.get());
 
   info_buffer_ = info_buf;
   callback_ = callback;  // cleared on completion
-  OpenEntryIfNeededAndContinue();
+  OpenEntryIfNeeded();
 }
 
 void AppCacheResponseReader::ContinueReadInfo() {
-  if (!entry_)  {
-    ScheduleIOCompletionCallback(net::ERR_CACHE_MISS);
-    return;
-  }
-
   int size = entry_->GetSize(kResponseInfoIndex);
   if (size <= 0) {
     ScheduleIOCompletionCallback(net::ERR_CACHE_MISS);
     return;
   }
 
   buffer_ = new net::IOBuffer(size);
   ReadRaw(kResponseInfoIndex, 0, buffer_.get(), size);
 }
 
 void AppCacheResponseReader::ReadData(net::IOBuffer* buf, int buf_len,
                                       const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   DCHECK(!IsReadPending());
   DCHECK(buf);
   DCHECK(buf_len >= 0);
   DCHECK(!buffer_.get());
   DCHECK(!info_buffer_.get());
 
   buffer_ = buf;
   buffer_len_ = buf_len;
   callback_ = callback;  // cleared on completion
-  OpenEntryIfNeededAndContinue();
+  OpenEntryIfNeeded();
 }
 
 void AppCacheResponseReader::ContinueReadData() {
-  if (!entry_)  {
-    ScheduleIOCompletionCallback(net::ERR_CACHE_MISS);
-    return;
-  }
-
   if (read_position_ + buffer_len_ > range_length_) {
     // TODO(michaeln): What about integer overflows?
     DCHECK(range_length_ >= read_position_);
     buffer_len_ = range_length_ - read_position_;
   }
   ReadRaw(kResponseContentIndex,
           range_offset_ + read_position_,
           buffer_.get(),
           buffer_len_);
 }
 
 void AppCacheResponseReader::SetReadRange(int offset, int length) {
   DCHECK(!IsReadPending() && !read_position_);
   range_offset_ = offset;
   range_length_ = length;
 }
 
 void AppCacheResponseReader::OnIOComplete(int result) {
   if (result >= 0) {
-    if (info_buffer_.get()) {
+    if (reading_metadata_size_) {
+      DCHECK(reading_metadata_size_ == result);
+      DCHECK(info_buffer_->http_info->metadata);
+      reading_metadata_size_ = 0;
+    } else if (info_buffer_.get()) {
       // Deserialize the http info structure, ensuring we got headers.
       Pickle pickle(buffer_->data(), result);
       scoped_ptr<net::HttpResponseInfo> info(new net::HttpResponseInfo);
       bool response_truncated = false;
       if (!info->InitFromPickle(pickle, &response_truncated) ||
           !info->headers.get()) {
         InvokeUserCompletionCallback(net::ERR_FAILED);
         return;
       }
       DCHECK(!response_truncated);
       info_buffer_->http_info.reset(info.release());
 
       // Also return the size of the response body
       DCHECK(entry_);
       info_buffer_->response_data_size =
           entry_->GetSize(kResponseContentIndex);
+
+      int64 metadata_size = entry_->GetSize(kResponseMetadataIndex);
+      if (metadata_size > 0) {
+        reading_metadata_size_ = metadata_size;
+        info_buffer_->http_info->metadata =
+            new net::IOBufferWithSize(metadata_size);
+        ReadRaw(kResponseMetadataIndex, 0,
+                info_buffer_->http_info->metadata.get(), metadata_size);
+        return;
+      }
     } else {
       read_position_ += result;
     }
   }
   InvokeUserCompletionCallback(result);
 }
 
-void AppCacheResponseReader::OpenEntryIfNeededAndContinue() {
-  int rv;
-  AppCacheDiskCacheInterface::Entry** entry_ptr = NULL;
-  if (entry_) {
-    rv = net::OK;
-  } else if (!disk_cache_) {
-    rv = net::ERR_FAILED;
-  } else {
-    entry_ptr = new AppCacheDiskCacheInterface::Entry*;
-    open_callback_ =
-        base::Bind(&AppCacheResponseReader::OnOpenEntryComplete,
-                   weak_factory_.GetWeakPtr(), base::Owned(entry_ptr));
-    rv = disk_cache_->OpenEntry(response_id_, entry_ptr, open_callback_);
+void AppCacheResponseReader::OnOpenEntryComplete() {
+  if (!entry_)  {
+    ScheduleIOCompletionCallback(net::ERR_CACHE_MISS);
+    return;
   }
-
-  if (rv != net::ERR_IO_PENDING)
-    OnOpenEntryComplete(entry_ptr, rv);
-}
-
-void AppCacheResponseReader::OnOpenEntryComplete(
-    AppCacheDiskCacheInterface::Entry** entry, int rv) {
-  DCHECK(info_buffer_.get() || buffer_.get());
-
-  if (!open_callback_.is_null()) {
-    if (rv == net::OK) {
-      DCHECK(entry);
-      entry_ = *entry;
-    }
-    open_callback_.Reset();
-  }
-
   if (info_buffer_.get())
     ContinueReadInfo();
   else
     ContinueReadData();
 }
 
 // AppCacheResponseWriter ----------------------------------------------
 
 AppCacheResponseWriter::AppCacheResponseWriter(
     int64 response_id, int64 group_id, AppCacheDiskCacheInterface* disk_cache)
@@ skipping 127 matching lines @@
 
     create_callback_.Reset();
   }
 
   if (info_buffer_.get())
     ContinueWriteInfo();
   else
     ContinueWriteData();
 }
 
+// AppCacheResponseMetadataWriter ----------------------------------------------
+
+AppCacheResponseMetadataWriter::AppCacheResponseMetadataWriter(
+    int64 response_id,
+    int64 group_id,
+    AppCacheDiskCacheInterface* disk_cache)
+    : AppCacheResponseIO(response_id, group_id, disk_cache),
+      write_amount_(0),
+      weak_factory_(this) {
+}
+
+AppCacheResponseMetadataWriter::~AppCacheResponseMetadataWriter() {
+}
+
+void AppCacheResponseMetadataWriter::WriteMetadata(
+    net::IOBuffer* buf,
+    int buf_len,
+    const net::CompletionCallback& callback) {
+  DCHECK(!callback.is_null());
+  DCHECK(!IsIOPending());
+  DCHECK(buf);
+  DCHECK(buf_len >= 0);
+  DCHECK(!buffer_.get());
+
+  buffer_ = buf;
+  write_amount_ = buf_len;
+  callback_ = callback;  // cleared on completion
+  OpenEntryIfNeeded();
+}
+
+void AppCacheResponseMetadataWriter::OnOpenEntryComplete() {
+  if (!entry_) {
+    ScheduleIOCompletionCallback(net::ERR_FAILED);
+    return;
+  }
+  WriteRaw(kResponseMetadataIndex, 0, buffer_.get(), write_amount_);
+}
+
+void AppCacheResponseMetadataWriter::OnIOComplete(int result) {
+  DCHECK(result < 0 || write_amount_ == result);
+  InvokeUserCompletionCallback(result);
+}
+
 }  // namespace content