[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 <stddef.h>
 #include <stdint.h>
 #include <map>
 #include <vector>
 
 #include "base/macros.h"
+#include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "net/base/completion_callback.h"
 #include "storage/browser/storage_browser_export.h"
 
 class GURL;
 
 namespace base {
 class FilePath;
 class SequencedTaskRunner;
@@ skipping 85 matching lines @@
   // Returns the total size of the blob. This is populated after CalculateSize
   // is called.
   uint64_t total_size() const {
     DCHECK(total_size_calculated_);
     return total_size_;
   }
 
  protected:
   friend class BlobDataHandle;
   friend class BlobReaderTest;
+  FRIEND_TEST_ALL_PREFIXES(BlobReaderTest, HandleBeforeAsyncCancel);
 
   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_