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