| 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.h" | |
| 9 #include "base/time.h" | |
| 10 #include "testing/gtest/include/gtest/gtest.h" | |
| 11 #include "webkit/blob/blob_data_handle.h" | |
| 12 #include "webkit/blob/blob_storage_context.h" | |
| 13 #include "webkit/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 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 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 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); | |
| 125 ASSERT_TRUE(blob_data_handle.get()); | |
| 126 EXPECT_TRUE(*(blob_data_handle->data()) == *blob_data1); | |
| 127 | |
| 128 // Test a blob composed in part with another blob. | |
| 129 blob_data_handle = context.AddFinishedBlob(blob_data2); | |
| 130 ASSERT_TRUE(blob_data_handle.get()); | |
| 131 EXPECT_TRUE(*(blob_data_handle->data()) == *canonicalized_blob_data2); | |
| 132 } | |
| 133 | |
| 134 TEST(BlobStorageContextTest, PublicBlobUrls) { | |
| 135 BlobStorageContext context; | |
| 136 BlobStorageHost host(&context); | |
| 137 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 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 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 } // namespace webkit_blob | |
| OLD | NEW |