OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 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 #include "storage/browser/blob/blob_storage_context.h" | 5 #include "storage/browser/blob/blob_storage_context.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 | 8 |
9 #include "base/files/file_path.h" | 9 #include "base/files/file_path.h" |
10 #include "storage/browser/blob/blob_data_builder.h" | 10 #include "storage/browser/blob/blob_data_builder.h" |
(...skipping 30 matching lines...) Expand all Loading... |
41 scoped_refptr<ShareableBlobDataItem> CreateFileItem(size_t offset, | 41 scoped_refptr<ShareableBlobDataItem> CreateFileItem(size_t offset, |
42 size_t size) { | 42 size_t size) { |
43 std::unique_ptr<DataElement> element(new DataElement()); | 43 std::unique_ptr<DataElement> element(new DataElement()); |
44 element->SetToFilePathRange(base::FilePath(FILE_PATH_LITERAL("kFakePath")), | 44 element->SetToFilePathRange(base::FilePath(FILE_PATH_LITERAL("kFakePath")), |
45 offset, size, base::Time::Max()); | 45 offset, size, base::Time::Max()); |
46 return scoped_refptr<ShareableBlobDataItem>(new ShareableBlobDataItem( | 46 return scoped_refptr<ShareableBlobDataItem>(new ShareableBlobDataItem( |
47 new BlobDataItem(std::move(element)), | 47 new BlobDataItem(std::move(element)), |
48 ShareableBlobDataItem::POPULATED_WITHOUT_QUOTA)); | 48 ShareableBlobDataItem::POPULATED_WITHOUT_QUOTA)); |
49 }; | 49 }; |
50 | 50 |
51 scoped_refptr<ShareableBlobDataItem> CreateTempFileItem(size_t offset, | |
52 size_t size) { | |
53 std::unique_ptr<DataElement> element(new DataElement()); | |
54 element->SetToFilePathRange(BlobDataBuilder::GetFutureFileItemPath(0), | |
55 offset, size, base::Time()); | |
56 return scoped_refptr<ShareableBlobDataItem>( | |
57 new ShareableBlobDataItem(new BlobDataItem(std::move(element)), | |
58 ShareableBlobDataItem::QUOTA_NEEDED)); | |
59 }; | |
60 | |
61 void ExpectFirstSlice(const BlobSlice& slice, | 51 void ExpectFirstSlice(const BlobSlice& slice, |
62 scoped_refptr<ShareableBlobDataItem> source_item, | 52 scoped_refptr<ShareableBlobDataItem> source_item, |
63 size_t first_item_slice_offset, | 53 size_t first_item_slice_offset, |
64 size_t size) { | 54 size_t size) { |
65 EXPECT_TRUE(slice.first_source_item); | 55 EXPECT_TRUE(slice.first_source_item); |
66 EXPECT_EQ(first_item_slice_offset, slice.first_item_slice_offset); | 56 EXPECT_EQ(first_item_slice_offset, slice.first_item_slice_offset); |
67 | 57 |
68 ASSERT_LE(1u, slice.dest_items.size()); | 58 ASSERT_LE(1u, slice.dest_items.size()); |
69 | 59 const DataElement& dest_element = |
70 scoped_refptr<ShareableBlobDataItem> item = slice.dest_items[0]; | 60 slice.dest_items[0]->item()->data_element(); |
71 EXPECT_EQ(ShareableBlobDataItem::QUOTA_NEEDED, item->state()); | |
72 const DataElement& dest_element = item->item()->data_element(); | |
73 | 61 |
74 EXPECT_EQ(DataElement::TYPE_BYTES_DESCRIPTION, dest_element.type()); | 62 EXPECT_EQ(DataElement::TYPE_BYTES_DESCRIPTION, dest_element.type()); |
75 EXPECT_EQ(static_cast<uint64_t>(size), dest_element.length()); | 63 EXPECT_EQ(static_cast<uint64_t>(size), dest_element.length()); |
76 | 64 |
77 EXPECT_EQ(*source_item, *slice.first_source_item); | 65 EXPECT_EQ(*source_item, *slice.first_source_item); |
78 } | 66 } |
79 | 67 |
80 void ExpectLastSlice(const BlobSlice& slice, | 68 void ExpectLastSlice(const BlobSlice& slice, |
81 scoped_refptr<ShareableBlobDataItem> source_item, | 69 scoped_refptr<ShareableBlobDataItem> source_item, |
82 size_t size) { | 70 size_t size) { |
83 EXPECT_TRUE(slice.last_source_item); | 71 EXPECT_TRUE(slice.last_source_item); |
84 | 72 |
85 ASSERT_LE(2u, slice.dest_items.size()); | 73 ASSERT_LE(2u, slice.dest_items.size()); |
86 scoped_refptr<ShareableBlobDataItem> item = slice.dest_items.back(); | 74 const DataElement& dest_element = |
87 EXPECT_EQ(ShareableBlobDataItem::QUOTA_NEEDED, item->state()); | 75 slice.dest_items.back()->item()->data_element(); |
88 const DataElement& dest_element = item->item()->data_element(); | |
89 | 76 |
90 EXPECT_EQ(DataElement::TYPE_BYTES_DESCRIPTION, dest_element.type()); | 77 EXPECT_EQ(DataElement::TYPE_BYTES_DESCRIPTION, dest_element.type()); |
91 EXPECT_EQ(static_cast<uint64_t>(size), dest_element.length()); | 78 EXPECT_EQ(static_cast<uint64_t>(size), dest_element.length()); |
92 | 79 |
93 EXPECT_EQ(*source_item, *slice.last_source_item); | 80 EXPECT_EQ(*source_item, *slice.last_source_item); |
94 } | 81 } |
95 }; | 82 }; |
96 | 83 |
97 TEST_F(BlobSliceTest, FullItem) { | 84 TEST_F(BlobSliceTest, FullItem) { |
| 85 const std::string kBlobUUID = "kId"; |
98 const size_t kSize = 5u; | 86 const size_t kSize = 5u; |
99 | 87 |
100 BlobEntry data(kType, kDisposition); | 88 BlobEntry data(kType, kDisposition); |
101 scoped_refptr<ShareableBlobDataItem> item = CreateDataItem(kSize); | 89 scoped_refptr<ShareableBlobDataItem> item = CreateDataItem(kSize); |
102 data.AppendSharedBlobItem(item); | 90 data.AppendSharedBlobItem(item); |
103 | 91 |
104 BlobSlice slice(data, 0, 5); | 92 BlobSlice slice(data, 0, 5); |
105 EXPECT_EQ(0u, slice.copying_memory_size.ValueOrDie()); | 93 EXPECT_EQ(0u, slice.copying_memory_size.ValueOrDie()); |
106 EXPECT_FALSE(slice.first_source_item); | 94 EXPECT_FALSE(slice.first_source_item); |
107 EXPECT_FALSE(slice.last_source_item); | 95 EXPECT_FALSE(slice.last_source_item); |
108 EXPECT_FALSE(slice.first_source_item); | 96 EXPECT_FALSE(slice.first_source_item); |
109 EXPECT_FALSE(slice.last_source_item); | 97 EXPECT_FALSE(slice.last_source_item); |
110 ASSERT_EQ(1u, slice.dest_items.size()); | 98 ASSERT_EQ(1u, slice.dest_items.size()); |
111 EXPECT_EQ(item, slice.dest_items[0]); | 99 EXPECT_EQ(item, slice.dest_items[0]); |
112 } | 100 } |
113 | 101 |
114 TEST_F(BlobSliceTest, SliceSingleItem) { | 102 TEST_F(BlobSliceTest, SliceSingleItem) { |
| 103 const std::string kBlobUUID = "kId"; |
115 const size_t kSize = 5u; | 104 const size_t kSize = 5u; |
116 | 105 |
117 BlobEntry data(kType, kDisposition); | 106 BlobEntry data(kType, kDisposition); |
118 scoped_refptr<ShareableBlobDataItem> item = CreateDataItem(kSize); | 107 scoped_refptr<ShareableBlobDataItem> item = CreateDataItem(kSize); |
119 data.AppendSharedBlobItem(item); | 108 data.AppendSharedBlobItem(item); |
120 | 109 |
121 BlobSlice slice(data, 1, 3); | 110 BlobSlice slice(data, 1, 3); |
122 EXPECT_EQ(3u, slice.copying_memory_size.ValueOrDie()); | 111 EXPECT_EQ(3u, slice.copying_memory_size.ValueOrDie()); |
123 EXPECT_FALSE(slice.last_source_item); | 112 EXPECT_FALSE(slice.last_source_item); |
124 ExpectFirstSlice(slice, item, 1, 3); | 113 ExpectFirstSlice(slice, item, 1, 3); |
125 ASSERT_EQ(1u, slice.dest_items.size()); | 114 ASSERT_EQ(1u, slice.dest_items.size()); |
126 } | 115 } |
127 | 116 |
128 TEST_F(BlobSliceTest, SliceSingleLastItem) { | 117 TEST_F(BlobSliceTest, SliceSingleLastItem) { |
| 118 const std::string kBlobUUID = "kId"; |
129 const size_t kSize1 = 5u; | 119 const size_t kSize1 = 5u; |
130 const size_t kSize2 = 10u; | 120 const size_t kSize2 = 10u; |
131 | 121 |
132 BlobEntry data(kType, kDisposition); | 122 BlobEntry data(kType, kDisposition); |
133 scoped_refptr<ShareableBlobDataItem> item1 = CreateDataItem(kSize1); | 123 scoped_refptr<ShareableBlobDataItem> item1 = CreateDataItem(kSize1); |
134 scoped_refptr<ShareableBlobDataItem> item2 = CreateDataItem(kSize2); | 124 scoped_refptr<ShareableBlobDataItem> item2 = CreateDataItem(kSize2); |
135 data.AppendSharedBlobItem(item1); | 125 data.AppendSharedBlobItem(item1); |
136 data.AppendSharedBlobItem(item2); | 126 data.AppendSharedBlobItem(item2); |
137 | 127 |
138 BlobSlice slice(data, 6, 2); | 128 BlobSlice slice(data, 6, 2); |
139 EXPECT_EQ(2u, slice.copying_memory_size.ValueOrDie()); | 129 EXPECT_EQ(2u, slice.copying_memory_size.ValueOrDie()); |
140 ExpectFirstSlice(slice, item2, 1, 2); | 130 ExpectFirstSlice(slice, item2, 1, 2); |
141 ASSERT_EQ(1u, slice.dest_items.size()); | 131 ASSERT_EQ(1u, slice.dest_items.size()); |
142 } | 132 } |
143 | 133 |
144 TEST_F(BlobSliceTest, SliceAcrossTwoItems) { | 134 TEST_F(BlobSliceTest, SliceAcrossTwoItems) { |
| 135 const std::string kBlobUUID = "kId"; |
145 const size_t kSize1 = 5u; | 136 const size_t kSize1 = 5u; |
146 const size_t kSize2 = 10u; | 137 const size_t kSize2 = 10u; |
147 | 138 |
148 BlobEntry data(kType, kDisposition); | 139 BlobEntry data(kType, kDisposition); |
149 scoped_refptr<ShareableBlobDataItem> item1 = CreateDataItem(kSize1); | 140 scoped_refptr<ShareableBlobDataItem> item1 = CreateDataItem(kSize1); |
150 scoped_refptr<ShareableBlobDataItem> item2 = CreateDataItem(kSize2); | 141 scoped_refptr<ShareableBlobDataItem> item2 = CreateDataItem(kSize2); |
151 data.AppendSharedBlobItem(item1); | 142 data.AppendSharedBlobItem(item1); |
152 data.AppendSharedBlobItem(item2); | 143 data.AppendSharedBlobItem(item2); |
153 | 144 |
154 BlobSlice slice(data, 4, 10); | 145 BlobSlice slice(data, 4, 10); |
155 EXPECT_EQ(10u, slice.copying_memory_size.ValueOrDie()); | 146 EXPECT_EQ(10u, slice.copying_memory_size.ValueOrDie()); |
156 ExpectFirstSlice(slice, item1, 4, 1); | 147 ExpectFirstSlice(slice, item1, 4, 1); |
157 ExpectLastSlice(slice, item2, 9); | 148 ExpectLastSlice(slice, item2, 9); |
158 ASSERT_EQ(2u, slice.dest_items.size()); | 149 ASSERT_EQ(2u, slice.dest_items.size()); |
159 } | 150 } |
160 | 151 |
161 TEST_F(BlobSliceTest, SliceFileAndLastItem) { | 152 TEST_F(BlobSliceTest, SliceFileAndLastItem) { |
| 153 const std::string kBlobUUID = "kId"; |
162 const size_t kSize1 = 5u; | 154 const size_t kSize1 = 5u; |
163 const size_t kSize2 = 10u; | 155 const size_t kSize2 = 10u; |
164 | 156 |
165 BlobEntry data(kType, kDisposition); | 157 BlobEntry data(kType, kDisposition); |
166 scoped_refptr<ShareableBlobDataItem> item1 = CreateFileItem(0u, kSize1); | 158 scoped_refptr<ShareableBlobDataItem> item1 = CreateFileItem(0u, kSize1); |
167 scoped_refptr<ShareableBlobDataItem> item2 = CreateDataItem(kSize2); | 159 scoped_refptr<ShareableBlobDataItem> item2 = CreateDataItem(kSize2); |
168 data.AppendSharedBlobItem(item1); | 160 data.AppendSharedBlobItem(item1); |
169 data.AppendSharedBlobItem(item2); | 161 data.AppendSharedBlobItem(item2); |
170 | 162 |
171 BlobSlice slice(data, 4, 2); | 163 BlobSlice slice(data, 4, 2); |
172 EXPECT_EQ(1u, slice.copying_memory_size.ValueOrDie()); | 164 EXPECT_EQ(1u, slice.copying_memory_size.ValueOrDie()); |
173 EXPECT_FALSE(slice.first_source_item); | 165 EXPECT_FALSE(slice.first_source_item); |
174 ExpectLastSlice(slice, item2, 1); | 166 ExpectLastSlice(slice, item2, 1); |
175 ASSERT_EQ(2u, slice.dest_items.size()); | 167 ASSERT_EQ(2u, slice.dest_items.size()); |
176 | 168 |
177 EXPECT_EQ(*CreateFileItem(4u, 1u)->item(), *slice.dest_items[0]->item()); | 169 EXPECT_EQ(*CreateFileItem(4u, 1u)->item(), *slice.dest_items[0]->item()); |
178 } | 170 } |
179 | 171 |
180 TEST_F(BlobSliceTest, SliceAcrossLargeItem) { | 172 TEST_F(BlobSliceTest, SliceAcrossLargeItem) { |
| 173 const std::string kBlobUUID = "kId"; |
181 const size_t kSize1 = 5u; | 174 const size_t kSize1 = 5u; |
182 const size_t kSize2 = 10u; | 175 const size_t kSize2 = 10u; |
183 const size_t kSize3 = 10u; | 176 const size_t kSize3 = 10u; |
184 | 177 |
185 BlobEntry data(kType, kDisposition); | 178 BlobEntry data(kType, kDisposition); |
186 scoped_refptr<ShareableBlobDataItem> item1 = CreateDataItem(kSize1); | 179 scoped_refptr<ShareableBlobDataItem> item1 = CreateDataItem(kSize1); |
187 scoped_refptr<ShareableBlobDataItem> item2 = CreateFileItem(0u, kSize2); | 180 scoped_refptr<ShareableBlobDataItem> item2 = CreateFileItem(0u, kSize2); |
188 scoped_refptr<ShareableBlobDataItem> item3 = CreateDataItem(kSize3); | 181 scoped_refptr<ShareableBlobDataItem> item3 = CreateDataItem(kSize3); |
189 data.AppendSharedBlobItem(item1); | 182 data.AppendSharedBlobItem(item1); |
190 data.AppendSharedBlobItem(item2); | 183 data.AppendSharedBlobItem(item2); |
191 data.AppendSharedBlobItem(item3); | 184 data.AppendSharedBlobItem(item3); |
192 | 185 |
193 BlobSlice slice(data, 2, 20); | 186 BlobSlice slice(data, 2, 20); |
194 EXPECT_EQ(3u + 7u, slice.copying_memory_size.ValueOrDie()); | 187 EXPECT_EQ(3u + 7u, slice.copying_memory_size.ValueOrDie()); |
195 ExpectFirstSlice(slice, item1, 2, 3); | 188 ExpectFirstSlice(slice, item1, 2, 3); |
196 ExpectLastSlice(slice, item3, 7); | 189 ExpectLastSlice(slice, item3, 7); |
197 ASSERT_EQ(3u, slice.dest_items.size()); | 190 ASSERT_EQ(3u, slice.dest_items.size()); |
198 | 191 |
199 EXPECT_EQ(*item2, *slice.dest_items[1]); | 192 EXPECT_EQ(*item2, *slice.dest_items[1]); |
200 } | 193 } |
201 | 194 |
202 TEST_F(BlobSliceTest, SliceTempFileItem) { | |
203 BlobEntry data(kType, kDisposition); | |
204 scoped_refptr<ShareableBlobDataItem> item1 = CreateTempFileItem(1u, 10u); | |
205 data.AppendSharedBlobItem(item1); | |
206 BlobSlice slice(data, 2, 5); | |
207 EXPECT_EQ(0u, slice.copying_memory_size.ValueOrDie()); | |
208 EXPECT_TRUE(slice.first_source_item); | |
209 EXPECT_EQ(2u, slice.first_item_slice_offset); | |
210 ASSERT_LE(1u, slice.dest_items.size()); | |
211 scoped_refptr<ShareableBlobDataItem> item = slice.dest_items[0]; | |
212 EXPECT_EQ(ShareableBlobDataItem::POPULATED_WITHOUT_QUOTA, item->state()); | |
213 | |
214 const DataElement& dest_element = item->item()->data_element(); | |
215 EXPECT_EQ(DataElement::TYPE_FILE, dest_element.type()); | |
216 EXPECT_EQ(static_cast<uint64_t>(5), dest_element.length()); | |
217 EXPECT_EQ(*item1, *slice.first_source_item); | |
218 ASSERT_EQ(1u, slice.dest_items.size()); | |
219 } | |
220 | |
221 } // namespace storage | 195 } // namespace storage |
OLD | NEW |