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