OLD | NEW |
1 // Copyright (c) 2015 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #ifndef STORAGE_BROWSER_BLOB_BLOB_DATA_BUILDER_H_ | 5 #ifndef STORAGE_BROWSER_BLOB_BLOB_DATA_BUILDER_H_ |
6 #define STORAGE_BROWSER_BLOB_BLOB_DATA_BUILDER_H_ | 6 #define STORAGE_BROWSER_BLOB_BLOB_DATA_BUILDER_H_ |
7 | 7 |
8 #include <stdint.h> | 8 #include <stdint.h> |
| 9 #include <ostream> |
9 #include <string> | 10 #include <string> |
10 #include <vector> | 11 #include <vector> |
11 | 12 |
12 #include "base/basictypes.h" | 13 #include "base/basictypes.h" |
13 #include "base/files/file_path.h" | 14 #include "base/files/file_path.h" |
14 #include "base/memory/ref_counted.h" | 15 #include "base/memory/ref_counted.h" |
15 #include "storage/browser/blob/blob_data_item.h" | 16 #include "storage/browser/blob/blob_data_item.h" |
16 #include "storage/browser/blob/blob_data_snapshot.h" | 17 #include "storage/browser/blob/blob_data_snapshot.h" |
17 #include "storage/browser/storage_browser_export.h" | 18 #include "storage/browser/storage_browser_export.h" |
18 | 19 |
19 namespace disk_cache { | 20 namespace disk_cache { |
20 class Entry; | 21 class Entry; |
21 } | 22 } |
22 | 23 |
23 namespace storage { | 24 namespace storage { |
24 class BlobStorageContext; | 25 class BlobStorageContext; |
25 | 26 |
26 class STORAGE_EXPORT BlobDataBuilder { | 27 class STORAGE_EXPORT BlobDataBuilder { |
27 public: | 28 public: |
28 using DataHandle = BlobDataItem::DataHandle; | 29 using DataHandle = BlobDataItem::DataHandle; |
29 | 30 |
30 explicit BlobDataBuilder(const std::string& uuid); | 31 explicit BlobDataBuilder(const std::string& uuid); |
31 ~BlobDataBuilder(); | 32 ~BlobDataBuilder(); |
32 | 33 |
33 const std::string& uuid() const { return uuid_; } | 34 const std::string& uuid() const { return uuid_; } |
34 | 35 |
| 36 // Validates the data element that was sent over IPC, and copies the data if |
| 37 // it's a 'bytes' element. Data elements of BYTES_DESCRIPTION or |
| 38 // DISK_CACHE_ENTRY types are not valid IPC data element types, and cannot be |
| 39 // given to this method. |
| 40 void AppendIPCDataElement(const DataElement& ipc_data); |
| 41 |
| 42 // Copies the given data into the blob. |
35 void AppendData(const std::string& data) { | 43 void AppendData(const std::string& data) { |
36 AppendData(data.c_str(), data.size()); | 44 AppendData(data.c_str(), data.size()); |
37 } | 45 } |
38 | 46 |
| 47 // Copies the given data into the blob. |
39 void AppendData(const char* data, size_t length); | 48 void AppendData(const char* data, size_t length); |
40 | 49 |
| 50 // Adds an item that is flagged for future data population. The memory is not |
| 51 // allocated until the first call to PopulateFutureData. Returns the index of |
| 52 // the item (to be used in PopulateFutureData). |
| 53 // Length cannot be 0. |
| 54 size_t AppendFutureData(size_t length); |
| 55 |
| 56 // Populates a part of an item previously allocated with AppendFutureData. |
| 57 // The first call to PopulateFutureData lazily allocates the memory for the |
| 58 // data element. |
| 59 // Returns true if: |
| 60 // * The item was created by using AppendFutureData, |
| 61 // * The offset and length are valid, and |
| 62 // * data is a valid pointer. |
| 63 bool PopulateFutureData(size_t index, |
| 64 const char* data, |
| 65 size_t offset, |
| 66 size_t length); |
| 67 |
41 // You must know the length of the file, you cannot use kuint64max to specify | 68 // You must know the length of the file, you cannot use kuint64max to specify |
42 // the whole file. This method creates a ShareableFileReference to the given | 69 // the whole file. This method creates a ShareableFileReference to the given |
43 // file, which is stored in this builder. | 70 // file, which is stored in this builder. |
44 void AppendFile(const base::FilePath& file_path, | 71 void AppendFile(const base::FilePath& file_path, |
45 uint64_t offset, | 72 uint64_t offset, |
46 uint64_t length, | 73 uint64_t length, |
47 const base::Time& expected_modification_time); | 74 const base::Time& expected_modification_time); |
48 | 75 |
49 void AppendBlob(const std::string& uuid, uint64_t offset, uint64_t length); | 76 void AppendBlob(const std::string& uuid, uint64_t offset, uint64_t length); |
50 | 77 |
51 void AppendBlob(const std::string& uuid); | 78 void AppendBlob(const std::string& uuid); |
52 | 79 |
53 void AppendFileSystemFile(const GURL& url, | 80 void AppendFileSystemFile(const GURL& url, |
54 uint64_t offset, | 81 uint64_t offset, |
55 uint64_t length, | 82 uint64_t length, |
56 const base::Time& expected_modification_time); | 83 const base::Time& expected_modification_time); |
57 | 84 |
58 void AppendDiskCacheEntry(const scoped_refptr<DataHandle>& data_handle, | 85 void AppendDiskCacheEntry(const scoped_refptr<DataHandle>& data_handle, |
59 disk_cache::Entry* disk_cache_entry, | 86 disk_cache::Entry* disk_cache_entry, |
60 int disk_cache_stream_index); | 87 int disk_cache_stream_index); |
61 | 88 |
62 void set_content_type(const std::string& content_type) { | 89 void set_content_type(const std::string& content_type) { |
63 content_type_ = content_type; | 90 content_type_ = content_type; |
64 } | 91 } |
65 | 92 |
66 void set_content_disposition(const std::string& content_disposition) { | 93 void set_content_disposition(const std::string& content_disposition) { |
67 content_disposition_ = content_disposition; | 94 content_disposition_ = content_disposition; |
68 } | 95 } |
69 | 96 |
| 97 void Clear(); |
| 98 |
70 private: | 99 private: |
71 friend class BlobStorageContext; | 100 friend class BlobStorageContext; |
| 101 friend class BlobAsyncBuilderHostTest; |
72 friend bool operator==(const BlobDataBuilder& a, const BlobDataBuilder& b); | 102 friend bool operator==(const BlobDataBuilder& a, const BlobDataBuilder& b); |
73 friend bool operator==(const BlobDataSnapshot& a, const BlobDataBuilder& b); | 103 friend bool operator==(const BlobDataSnapshot& a, const BlobDataBuilder& b); |
| 104 friend STORAGE_EXPORT void PrintTo(const BlobDataBuilder& x, |
| 105 ::std::ostream* os); |
74 | 106 |
75 std::string uuid_; | 107 std::string uuid_; |
76 std::string content_type_; | 108 std::string content_type_; |
77 std::string content_disposition_; | 109 std::string content_disposition_; |
78 std::vector<scoped_refptr<BlobDataItem>> items_; | 110 std::vector<scoped_refptr<BlobDataItem>> items_; |
79 | 111 |
80 DISALLOW_COPY_AND_ASSIGN(BlobDataBuilder); | 112 DISALLOW_COPY_AND_ASSIGN(BlobDataBuilder); |
81 }; | 113 }; |
82 | 114 |
83 #if defined(UNIT_TEST) | 115 #if defined(UNIT_TEST) |
84 inline bool operator==(const BlobDataBuilder& a, const BlobDataBuilder& b) { | 116 inline bool operator==(const BlobDataBuilder& a, const BlobDataBuilder& b) { |
85 if (a.content_type_ != b.content_type_) | 117 if (a.content_type_ != b.content_type_) |
86 return false; | 118 return false; |
87 if (a.content_disposition_ != b.content_disposition_) | 119 if (a.content_disposition_ != b.content_disposition_) |
88 return false; | 120 return false; |
89 if (a.items_.size() != b.items_.size()) | 121 if (a.items_.size() != b.items_.size()) |
90 return false; | 122 return false; |
91 for (size_t i = 0; i < a.items_.size(); ++i) { | 123 for (size_t i = 0; i < a.items_.size(); ++i) { |
92 if (a.items_[i] != b.items_[i]) | 124 if (*(a.items_[i]) != *(b.items_[i])) |
93 return false; | 125 return false; |
94 } | 126 } |
95 return true; | 127 return true; |
96 } | 128 } |
97 | 129 |
98 inline bool operator==(const BlobDataSnapshot& a, const BlobDataBuilder& b) { | 130 inline bool operator==(const BlobDataSnapshot& a, const BlobDataBuilder& b) { |
99 if (a.content_type() != b.content_type_) { | 131 if (a.content_type() != b.content_type_) { |
100 return false; | 132 return false; |
101 } | 133 } |
102 if (a.content_disposition() != b.content_disposition_) { | 134 if (a.content_disposition() != b.content_disposition_) { |
103 return false; | 135 return false; |
104 } | 136 } |
105 if (a.items().size() != b.items_.size()) { | 137 if (a.items().size() != b.items_.size()) { |
106 return false; | 138 return false; |
107 } | 139 } |
108 for (size_t i = 0; i < a.items().size(); ++i) { | 140 for (size_t i = 0; i < a.items().size(); ++i) { |
109 if (*(a.items()[i]) != *(b.items_[i])) | 141 if (*(a.items()[i]) != *(b.items_[i])) |
110 return false; | 142 return false; |
111 } | 143 } |
112 return true; | 144 return true; |
113 } | 145 } |
114 | 146 |
115 inline bool operator!=(const BlobDataSnapshot& a, const BlobDataBuilder& b) { | 147 inline bool operator!=(const BlobDataSnapshot& a, const BlobDataBuilder& b) { |
116 return !(a == b); | 148 return !(a == b); |
117 } | 149 } |
118 | 150 |
119 inline bool operator!=(const BlobDataBuilder& a, const BlobDataBuilder& b) { | 151 inline bool operator!=(const BlobDataBuilder& a, const BlobDataBuilder& b) { |
120 return !(a == b); | 152 return !(a == b); |
121 } | 153 } |
| 154 |
122 #endif // defined(UNIT_TEST) | 155 #endif // defined(UNIT_TEST) |
123 | 156 |
124 } // namespace storage | 157 } // namespace storage |
125 #endif // STORAGE_BROWSER_BLOB_BLOB_DATA_BUILDER_H_ | 158 #endif // STORAGE_BROWSER_BLOB_BLOB_DATA_BUILDER_H_ |
OLD | NEW |