[BlobAsync] Asynchronous Blob Construction Final Patch

storage/browser/blob/blob_reader.h

 // Copyright 2015 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 STORAGE_BROWSER_BLOB_BLOB_READER_H_
 #define STORAGE_BROWSER_BLOB_BLOB_READER_H_
 
 #include <stdint.h>
 #include <map>
 #include <vector>
@@ skipping 105 matching lines @@
   BlobReader(const BlobDataHandle* blob_handle,
              scoped_ptr<FileStreamReaderProvider> file_stream_provider,
              base::SequencedTaskRunner* file_task_runner);
 
   bool total_size_calculated() const { return total_size_calculated_; }
 
  private:
   Status ReportError(int net_error);
   void InvalidateCallbacksAndDone(int net_error, net::CompletionCallback done);
 
+  void AsyncCalculateSize(const net::CompletionCallback& done,
+                          bool async_succeeded);
+  Status CalculateSizeImpl(const net::CompletionCallback& done);
   bool AddItemLength(size_t index, uint64_t length);
   bool ResolveFileItemLength(const BlobDataItem& item,
                              int64_t total_length,
                              uint64_t* output_length);
   void DidGetFileItemLength(size_t index, int64_t result);
   void DidCountSize();
 
   // For reading the blob.
   // Returns if we're done, PENDING_IO if we're waiting on async.
   Status ReadLoop(int* bytes_read);
@@ skipping 16 matching lines @@
   // Returns a FileStreamReader for a blob item at |index|.
   // If the item at |index| is not of file this returns NULL.
   FileStreamReader* GetOrCreateFileReaderAtIndex(size_t index);
   // If the reader is null, then this basically performs a delete operation.
   void SetFileReaderAtIndex(size_t index, scoped_ptr<FileStreamReader> reader);
   // Creates a FileStreamReader for the item with additional_offset.
   scoped_ptr<FileStreamReader> CreateFileStreamReader(
       const BlobDataItem& item,
       uint64_t additional_offset);
 
+  scoped_ptr<BlobDataHandle> blob_handle_;
   scoped_ptr<BlobDataSnapshot> blob_data_;
   scoped_ptr<FileStreamReaderProvider> file_stream_provider_;
   scoped_refptr<base::SequencedTaskRunner> file_task_runner_;
 
   int net_error_;
   bool item_list_populated_ = false;
   std::vector<uint64_t> item_length_list_;
 
   scoped_refptr<net::DrainableIOBuffer> read_buf_;
 
   bool total_size_calculated_ = false;
   uint64_t total_size_ = 0;
   uint64_t remaining_bytes_ = 0;
   size_t pending_get_file_info_count_ = 0;
   std::map<size_t, FileStreamReader*> index_to_reader_;
   size_t current_item_index_ = 0;
   uint64_t current_item_offset_ = 0;
 
   bool io_pending_ = false;
 
   net::CompletionCallback size_callback_;
   net::CompletionCallback read_callback_;
 
   base::WeakPtrFactory<BlobReader> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(BlobReader);
 };
 
 }  // namespace storage
 #endif  // STORAGE_BROWSER_BLOB_BLOB_READER_H_