[BlobAsync] Disk support for blob storage

storage/browser/blob/blob_data_builder.h

 // Copyright (c) 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_DATA_BUILDER_H_
 #define STORAGE_BROWSER_BLOB_BLOB_DATA_BUILDER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 #include <ostream>
 #include <string>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "storage/browser/blob/blob_data_item.h"
 #include "storage/browser/blob/blob_data_snapshot.h"
+#include "storage/browser/blob/shareable_file_reference.h"
 #include "storage/browser/storage_browser_export.h"
 
 namespace disk_cache {
 class Entry;
 }
 
 namespace storage {
 class BlobStorageContext;
 class ShareableFileReference;
 
+// This class is used to build blobs. It also facilitates the operation of
+// 'pending' data, where the user knows the size and existence of a file or
+// bytes item, but we don't have the memory or file yet. See AppendFuture* and
+// PopulateFuture* methods for more description. Use
+// BlobDataHandle::GetBlobStatus to check for an error after creating the blob.
 class STORAGE_EXPORT BlobDataBuilder {
  public:
   using DataHandle = BlobDataItem::DataHandle;
+  // Visible for tesing.
+  static const char kAppendFutureFileTemporaryFileName[];

[michaeln, 2016/08/15 22:44:44]

please use shorter symbols, kFutureFileName[]

[dmurph, 2016/08/19 00:18:32]

Done.

 
-  // This is the filename used for the temporary file items added by
-  // AppendFutureFile.
-  const static char kAppendFutureFileTemporaryFileName[];
+  // Use this function to tell if an item was added using AppendFutureFile.
+  static bool IsTemporaryFileItem(const DataElement& element);

[michaeln, 2016/08/15 22:44:44]

please use consistent terminology, "future" or "temporary", pick one, i like
"future"

[dmurph, 2016/08/19 00:18:32]

Done.

+  // Generated from |file_id| given in AppendFutureFile.

[michaeln, 2016/08/15 22:44:44]

what does this function do? oh?

[dmurph, 2016/08/19 00:18:32]

Done.

+  static std::string GetTemporaryFileID(const DataElement& element);

[michaeln, 2016/08/15 22:44:44]

there's mysteriousness around file_ids and future files that could be clarified
some?

FilePath FormFutureFilename(id);
string ExtractFutureFileId(path);

can the file_id types be an int?

[dmurph, 2016/08/19 00:18:32]

Done.

 
   explicit BlobDataBuilder(const std::string& uuid);
   ~BlobDataBuilder();
 
   const std::string& uuid() const { return uuid_; }
 
   // Validates the data element that was sent over IPC, and copies the data if
   // it's a 'bytes' element. Data elements of BYTES_DESCRIPTION or
   // DISK_CACHE_ENTRY types are not valid IPC data element types, and cannot be
   // given to this method.
@@ skipping 20 matching lines @@
   // * The offset and length are valid, and
   // * data is a valid pointer.
   bool PopulateFutureData(size_t index,
                           const char* data,
                           size_t offset,
                           size_t length);
 
   // Adds an item that is flagged for future data population. Use
   // 'PopulateFutureFile' to set the file path and expected modification time
   // of this file. Returns the index of the item (to be used in
-  // PopulateFutureFile). The temporary filename used by this method is
-  // kAppendFutureFileTemporaryFileName. |length| cannot be 0.
-  size_t AppendFutureFile(uint64_t offset, uint64_t length);
+  // PopulateFutureFile). |length| cannot be 0.
+  // |file_id| should correspond to the file handle used to store this item,
+  // which needs to be unique on a per-builder bases. This is used by the
+  // BlobMemoryController class to determine the number and size of files it
+  // needs to create for a blob.
+  size_t AppendFutureFile(uint64_t offset,
+                          uint64_t length,
+                          const std::string& file_id);
 
   // Populates a part of an item previously allocated with AppendFutureFile.
   // Returns true if:
   // * The item was created by using AppendFutureFile and
   // * The filepath is valid.
   bool PopulateFutureFile(
       size_t index,
       const scoped_refptr<ShareableFileReference>& file_reference,
       const base::Time& expected_modification_time);
 
@@ skipping 10 matching lines @@
   void AppendBlob(const std::string& uuid);
 
   void AppendFileSystemFile(const GURL& url,
                             uint64_t offset,
                             uint64_t length,
                             const base::Time& expected_modification_time);
 
   void AppendDiskCacheEntry(const scoped_refptr<DataHandle>& data_handle,
                             disk_cache::Entry* disk_cache_entry,
                             int disk_cache_stream_index);
+
   // The content of the side data is accessible with BlobReader::ReadSideData().
   void AppendDiskCacheEntryWithSideData(
       const scoped_refptr<DataHandle>& data_handle,
       disk_cache::Entry* disk_cache_entry,
       int disk_cache_stream_index,
       int disk_cache_side_stream_index);
 
   void set_content_type(const std::string& content_type) {
     content_type_ = content_type;
   }
 
   void set_content_disposition(const std::string& content_disposition) {
     content_disposition_ = content_disposition;
   }
 
   void Clear();
 
  private:
+  friend class BlobAsyncBuilderHostTest;
+  friend struct BlobFlattener;
   friend class BlobStorageContext;
-  friend class BlobAsyncBuilderHostTest;
+  FRIEND_TEST_ALL_PREFIXES(BlobStorageContextTest, BuildBlobFuzzy);
   friend bool operator==(const BlobDataBuilder& a, const BlobDataBuilder& b);
   friend bool operator==(const BlobDataSnapshot& a, const BlobDataBuilder& b);
   friend STORAGE_EXPORT void PrintTo(const BlobDataBuilder& x,
                                      ::std::ostream* os);
 
   std::string uuid_;
   std::string content_type_;
   std::string content_disposition_;
   std::vector<scoped_refptr<BlobDataItem>> items_;
 
@@ skipping 45 matching lines @@
 }
 
 inline bool operator!=(const BlobDataBuilder& a, const BlobDataSnapshot& b) {
   return b != a;
 }
 
 #endif  // defined(UNIT_TEST)
 
 }  // namespace storage
 #endif  // STORAGE_BROWSER_BLOB_BLOB_DATA_BUILDER_H_