OLD | NEW |
| (Empty) |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "base/files/file_path.h" | |
6 #include "base/memory/ref_counted.h" | |
7 #include "base/memory/scoped_ptr.h" | |
8 #include "base/message_loop/message_loop.h" | |
9 #include "base/time/time.h" | |
10 #include "testing/gtest/include/gtest/gtest.h" | |
11 #include "webkit/browser/blob/blob_data_handle.h" | |
12 #include "webkit/browser/blob/blob_storage_context.h" | |
13 #include "webkit/browser/blob/blob_storage_host.h" | |
14 | |
15 namespace webkit_blob { | |
16 | |
17 namespace { | |
18 void SetupBasicBlob(BlobStorageHost* host, const std::string& id) { | |
19 EXPECT_TRUE(host->StartBuildingBlob(id)); | |
20 BlobData::Item item; | |
21 item.SetToBytes("1", 1); | |
22 EXPECT_TRUE(host->AppendBlobDataItem(id, item)); | |
23 EXPECT_TRUE(host->FinishBuildingBlob(id, "text/plain")); | |
24 EXPECT_FALSE(host->StartBuildingBlob(id)); | |
25 } | |
26 } // namespace | |
27 | |
28 TEST(BlobStorageContextTest, IncrementDecrementRef) { | |
29 BlobStorageContext context; | |
30 BlobStorageHost host(&context); | |
31 base::MessageLoop fake_io_message_loop; | |
32 | |
33 // Build up a basic blob. | |
34 const std::string kId("id"); | |
35 SetupBasicBlob(&host, kId); | |
36 | |
37 // Make sure it's there, finish building implies a ref of one. | |
38 scoped_ptr<BlobDataHandle> blob_data_handle; | |
39 blob_data_handle = context.GetBlobDataFromUUID(kId); | |
40 EXPECT_TRUE(blob_data_handle); | |
41 blob_data_handle.reset(); | |
42 | |
43 // Make sure its still there after inc/dec. | |
44 EXPECT_TRUE(host.IncrementBlobRefCount(kId)); | |
45 EXPECT_TRUE(host.DecrementBlobRefCount(kId)); | |
46 blob_data_handle = context.GetBlobDataFromUUID(kId); | |
47 EXPECT_TRUE(blob_data_handle); | |
48 blob_data_handle.reset(); | |
49 | |
50 // Make sure it goes away in the end. | |
51 EXPECT_TRUE(host.DecrementBlobRefCount(kId)); | |
52 blob_data_handle = context.GetBlobDataFromUUID(kId); | |
53 EXPECT_FALSE(blob_data_handle); | |
54 EXPECT_FALSE(host.DecrementBlobRefCount(kId)); | |
55 EXPECT_FALSE(host.IncrementBlobRefCount(kId)); | |
56 } | |
57 | |
58 TEST(BlobStorageContextTest, BlobDataHandle) { | |
59 BlobStorageContext context; | |
60 BlobStorageHost host(&context); | |
61 base::MessageLoop fake_io_message_loop; | |
62 | |
63 // Build up a basic blob. | |
64 const std::string kId("id"); | |
65 SetupBasicBlob(&host, kId); | |
66 | |
67 // Get a handle to it. | |
68 scoped_ptr<BlobDataHandle> blob_data_handle = | |
69 context.GetBlobDataFromUUID(kId); | |
70 EXPECT_TRUE(blob_data_handle); | |
71 | |
72 // Drop the host's ref to it. | |
73 EXPECT_TRUE(host.DecrementBlobRefCount(kId)); | |
74 | |
75 // Should still be there due to the handle. | |
76 scoped_ptr<BlobDataHandle> another_handle = | |
77 context.GetBlobDataFromUUID(kId); | |
78 EXPECT_TRUE(another_handle); | |
79 | |
80 // Should disappear after dropping both handles. | |
81 blob_data_handle.reset(); | |
82 another_handle.reset(); | |
83 blob_data_handle = context.GetBlobDataFromUUID(kId); | |
84 EXPECT_FALSE(blob_data_handle); | |
85 } | |
86 | |
87 TEST(BlobStorageContextTest, CompoundBlobs) { | |
88 const std::string kId1("id1"); | |
89 const std::string kId2("id2"); | |
90 const std::string kId2Prime("id2.prime"); | |
91 | |
92 base::MessageLoop fake_io_message_loop; | |
93 | |
94 // Setup a set of blob data for testing. | |
95 base::Time time1, time2; | |
96 base::Time::FromString("Tue, 15 Nov 1994, 12:45:26 GMT", &time1); | |
97 base::Time::FromString("Mon, 14 Nov 1994, 11:30:49 GMT", &time2); | |
98 | |
99 scoped_refptr<BlobData> blob_data1(new BlobData(kId1)); | |
100 blob_data1->AppendData("Data1"); | |
101 blob_data1->AppendData("Data2"); | |
102 blob_data1->AppendFile(base::FilePath(FILE_PATH_LITERAL("File1.txt")), | |
103 10, 1024, time1); | |
104 | |
105 scoped_refptr<BlobData> blob_data2(new BlobData(kId2)); | |
106 blob_data2->AppendData("Data3"); | |
107 blob_data2->AppendBlob(kId1, 8, 100); | |
108 blob_data2->AppendFile(base::FilePath(FILE_PATH_LITERAL("File2.txt")), | |
109 0, 20, time2); | |
110 | |
111 scoped_refptr<BlobData> canonicalized_blob_data2(new BlobData(kId2Prime)); | |
112 canonicalized_blob_data2->AppendData("Data3"); | |
113 canonicalized_blob_data2->AppendData("a2___", 2); | |
114 canonicalized_blob_data2->AppendFile( | |
115 base::FilePath(FILE_PATH_LITERAL("File1.txt")), | |
116 10, 98, time1); | |
117 canonicalized_blob_data2->AppendFile( | |
118 base::FilePath(FILE_PATH_LITERAL("File2.txt")), 0, 20, time2); | |
119 | |
120 BlobStorageContext context; | |
121 scoped_ptr<BlobDataHandle> blob_data_handle; | |
122 | |
123 // Test a blob referring to only data and a file. | |
124 blob_data_handle = context.AddFinishedBlob(blob_data1.get()); | |
125 ASSERT_TRUE(blob_data_handle.get()); | |
126 EXPECT_TRUE(*(blob_data_handle->data()) == *blob_data1.get()); | |
127 | |
128 // Test a blob composed in part with another blob. | |
129 blob_data_handle = context.AddFinishedBlob(blob_data2.get()); | |
130 ASSERT_TRUE(blob_data_handle.get()); | |
131 EXPECT_TRUE(*(blob_data_handle->data()) == *canonicalized_blob_data2.get()); | |
132 } | |
133 | |
134 TEST(BlobStorageContextTest, PublicBlobUrls) { | |
135 BlobStorageContext context; | |
136 BlobStorageHost host(&context); | |
137 base::MessageLoop fake_io_message_loop; | |
138 | |
139 // Build up a basic blob. | |
140 const std::string kId("id"); | |
141 SetupBasicBlob(&host, kId); | |
142 | |
143 // Now register a url for that blob. | |
144 GURL kUrl("blob:id"); | |
145 EXPECT_TRUE(host.RegisterPublicBlobURL(kUrl, kId)); | |
146 scoped_ptr<BlobDataHandle> blob_data_handle = | |
147 context.GetBlobDataFromPublicURL(kUrl); | |
148 ASSERT_TRUE(blob_data_handle.get()); | |
149 EXPECT_EQ(kId, blob_data_handle->data()->uuid()); | |
150 blob_data_handle.reset(); | |
151 | |
152 // The url registration should keep the blob alive even after | |
153 // explicit references are dropped. | |
154 EXPECT_TRUE(host.DecrementBlobRefCount(kId)); | |
155 blob_data_handle = context.GetBlobDataFromPublicURL(kUrl); | |
156 EXPECT_TRUE(blob_data_handle); | |
157 blob_data_handle.reset(); | |
158 | |
159 // Finally get rid of the url registration and the blob. | |
160 EXPECT_TRUE(host.RevokePublicBlobURL(kUrl)); | |
161 blob_data_handle = context.GetBlobDataFromPublicURL(kUrl); | |
162 EXPECT_TRUE(!blob_data_handle.get()); | |
163 EXPECT_FALSE(host.RevokePublicBlobURL(kUrl)); | |
164 } | |
165 | |
166 TEST(BlobStorageContextTest, HostCleanup) { | |
167 BlobStorageContext context; | |
168 scoped_ptr<BlobStorageHost> host(new BlobStorageHost(&context)); | |
169 base::MessageLoop fake_io_message_loop; | |
170 | |
171 // Build up a basic blob and register a url | |
172 const std::string kId("id"); | |
173 GURL kUrl("blob:id"); | |
174 SetupBasicBlob(host.get(), kId); | |
175 EXPECT_TRUE(host->RegisterPublicBlobURL(kUrl, kId)); | |
176 | |
177 // All should disappear upon host deletion. | |
178 host.reset(); | |
179 scoped_ptr<BlobDataHandle> handle = context.GetBlobDataFromPublicURL(kUrl); | |
180 EXPECT_TRUE(!handle.get()); | |
181 handle = context.GetBlobDataFromUUID(kId); | |
182 EXPECT_TRUE(!handle.get()); | |
183 } | |
184 | |
185 TEST(BlobStorageContextTest, EarlyContextDeletion) { | |
186 scoped_ptr<BlobStorageContext> context(new BlobStorageContext); | |
187 BlobStorageHost host(context.get()); | |
188 base::MessageLoop fake_io_message_loop; | |
189 | |
190 // Deleting the context should not induce crashes. | |
191 context.reset(); | |
192 | |
193 const std::string kId("id"); | |
194 GURL kUrl("blob:id"); | |
195 EXPECT_FALSE(host.StartBuildingBlob(kId)); | |
196 BlobData::Item item; | |
197 item.SetToBytes("1", 1); | |
198 EXPECT_FALSE(host.AppendBlobDataItem(kId, item)); | |
199 EXPECT_FALSE(host.FinishBuildingBlob(kId, "text/plain")); | |
200 EXPECT_FALSE(host.RegisterPublicBlobURL(kUrl, kId)); | |
201 EXPECT_FALSE(host.IncrementBlobRefCount(kId)); | |
202 EXPECT_FALSE(host.DecrementBlobRefCount(kId)); | |
203 EXPECT_FALSE(host.RevokePublicBlobURL(kUrl)); | |
204 } | |
205 | |
206 // TODO(michaeln): tests for the depcrecated url stuff | |
207 | |
208 } // namespace webkit_blob | |
OLD | NEW |