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