Introduce AppCacheResponseMetadataWriter to support metadata caching.

content/browser/appcache/appcache_response.h

 // 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.
 
 #ifndef CONTENT_BROWSER_APPCACHE_APPCACHE_RESPONSE_H_
 #define CONTENT_BROWSER_APPCACHE_APPCACHE_RESPONSE_H_
 
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 88 matching lines @@
  public:
   virtual ~AppCacheResponseIO();
   int64 response_id() const { return response_id_; }
 
  protected:
   AppCacheResponseIO(int64 response_id,
                      int64 group_id,
                      AppCacheDiskCacheInterface* disk_cache);
 
   virtual void OnIOComplete(int result) = 0;
+  virtual void OnOpenEntryComplete() {}
 
   bool IsIOPending() { return !callback_.is_null(); }
   void ScheduleIOCompletionCallback(int result);
   void InvokeUserCompletionCallback(int result);
   void ReadRaw(int index, int offset, net::IOBuffer* buf, int buf_len);
   void WriteRaw(int index, int offset, net::IOBuffer* buf, int buf_len);
+  void OpenEntryIfNeeded();
 
   const int64 response_id_;
   const int64 group_id_;
   AppCacheDiskCacheInterface* disk_cache_;
   AppCacheDiskCacheInterface::Entry* entry_;
   scoped_refptr<HttpResponseInfoIOBuffer> info_buffer_;
   scoped_refptr<net::IOBuffer> buffer_;
   int buffer_len_;
   net::CompletionCallback callback_;
+  net::CompletionCallback open_callback_;
   base::WeakPtrFactory<AppCacheResponseIO> weak_factory_;
 
  private:
   void OnRawIOComplete(int result);
+  void OpenEntryCallback(AppCacheDiskCacheInterface::Entry** entry, int rv);
 };
 
 // Reads existing response data from storage. If the object is deleted
 // and there is a read in progress, the implementation will return
 // immediately but will take care of any side effect of cancelling the
 // operation.  In other words, instances are safe to delete at will.
 class CONTENT_EXPORT AppCacheResponseReader
     : public AppCacheResponseIO {
  public:
   ~AppCacheResponseReader() override;
@@ skipping 33 matching lines @@
  protected:
   friend class AppCacheStorageImpl;
   friend class content::MockAppCacheStorage;
 
   // Should only be constructed by the storage class and derivatives.
   AppCacheResponseReader(int64 response_id,
                          int64 group_id,
                          AppCacheDiskCacheInterface* disk_cache);
 
   void OnIOComplete(int result) override;
+  void OnOpenEntryComplete() override;
   void ContinueReadInfo();
   void ContinueReadData();
-  void OpenEntryIfNeededAndContinue();
-  void OnOpenEntryComplete(AppCacheDiskCacheInterface::Entry** entry, int rv);
 
   int range_offset_;
   int range_length_;
   int read_position_;
-  net::CompletionCallback open_callback_;
+  int reading_metadata_size_;
   base::WeakPtrFactory<AppCacheResponseReader> weak_factory_;
 };
 
 // Writes new response data to storage. If the object is deleted
 // and there is a write in progress, the implementation will return
 // immediately but will take care of any side effect of cancelling the
 // operation. In other words, instances are safe to delete at will.
 class CONTENT_EXPORT AppCacheResponseWriter
     : public AppCacheResponseIO {
  public:
@@ skipping 50 matching lines @@
   void OnCreateEntryComplete(AppCacheDiskCacheInterface::Entry** entry, int rv);
 
   int info_size_;
   int write_position_;
   int write_amount_;
   CreationPhase creation_phase_;
   net::CompletionCallback create_callback_;
   base::WeakPtrFactory<AppCacheResponseWriter> weak_factory_;
 };
 
+// Writes metadata of the existing response to storage. If the object is deleted
+// and there is a write in progress, the implementation will return
+// immediately but will take care of any side effect of cancelling the
+// operation. In other words, instances are safe to delete at will.
+class CONTENT_EXPORT AppCacheResponseMetadataWriter
+    : public AppCacheResponseIO {
+ public:
+  ~AppCacheResponseMetadataWriter() override;
+
+  // Writes metadata to storage. Always returns the result of the write
+  // asynchronously through the 'callback'. Returns the number of bytes written
+  // or a net:: error code. Guaranteed to not perform partial writes.
+  // The writer acquires a reference to the provided 'buf' until completion at
+  // which time the callback is invoked with either a negative error code or
+  // the number of bytes written. The 'callback' is a required parameter.
+  // The contents of 'buf' are not modified.
+  // Should only be called where there is no WriteMetadata operation in
+  // progress.
+  void WriteMetadata(net::IOBuffer* buf,
+                     int buf_len,
+                     const net::CompletionCallback& callback);
+
+  // Returns true if there is a write pending.
+  bool IsWritePending() { return IsIOPending(); }
+
+ protected:
+  friend class AppCacheStorageImpl;
+  friend class content::MockAppCacheStorage;
+  // Should only be constructed by the storage class and derivatives.
+  AppCacheResponseMetadataWriter(int64 response_id,
+                                 int64 group_id,
+                                 AppCacheDiskCacheInterface* disk_cache);
+
+ private:
+  void OnIOComplete(int result) override;
+  void OnOpenEntryComplete() override;
+
+  int write_amount_;
+  base::WeakPtrFactory<AppCacheResponseMetadataWriter> weak_factory_;
+};
+
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_APPCACHE_APPCACHE_RESPONSE_H_