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 15namespace webkit_blob { 16 17namespace { 18void 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 28TEST(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 58TEST(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 87TEST(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 134TEST(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 166TEST(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 185TEST(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 209