1 // Copyright 2014 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/bind.h"
6 #include "base/files/file_util.h"
7 #include "base/files/scoped_temp_dir.h"
8 #include "base/run_loop.h"
9 #include "base/single_thread_task_runner.h"
10 #include "base/thread_task_runner_handle.h"
11 #include "content/browser/appcache/appcache_disk_cache.h"
12 #include "net/base/io_buffer.h"
13 #include "net/base/net_errors.h"
14 #include "testing/gtest/include/gtest/gtest.h"
15
16 namespace content {
17
18 class AppCacheDiskCacheTest : public testing::Test {
19 public:
AppCacheDiskCacheTest()20 AppCacheDiskCacheTest() {}
21
SetUp()22 virtual void SetUp() OVERRIDE {
23 // Use the current thread for the DiskCache's cache_thread.
24 message_loop_.reset(new base::MessageLoopForIO());
25 cache_thread_ = base::ThreadTaskRunnerHandle::Get();
26 ASSERT_TRUE(directory_.CreateUniqueTempDir());
27 completion_callback_ = base::Bind(
28 &AppCacheDiskCacheTest::OnComplete,
29 base::Unretained(this));
30 }
31
TearDown()32 virtual void TearDown() OVERRIDE {
33 base::RunLoop().RunUntilIdle();
34 message_loop_.reset(NULL);
35 }
36
FlushCacheTasks()37 void FlushCacheTasks() {
38 base::RunLoop().RunUntilIdle();
39 }
40
OnComplete(int err)41 void OnComplete(int err) {
42 completion_results_.push_back(err);
43 }
44
45 base::ScopedTempDir directory_;
46 scoped_ptr<base::MessageLoop> message_loop_;
47 scoped_refptr<base::SingleThreadTaskRunner> cache_thread_;
48 net::CompletionCallback completion_callback_;
49 std::vector<int> completion_results_;
50
51 static const int k10MBytes = 10 * 1024 * 1024;
52 };
53
TEST_F(AppCacheDiskCacheTest,DisablePriorToInitCompletion)54 TEST_F(AppCacheDiskCacheTest, DisablePriorToInitCompletion) {
55 AppCacheDiskCache::Entry* entry = NULL;
56
57 // Create an instance and start it initializing, queue up
58 // one of each kind of "entry" function.
59 scoped_ptr<AppCacheDiskCache> disk_cache(new AppCacheDiskCache);
60 EXPECT_FALSE(disk_cache->is_disabled());
61 disk_cache->InitWithDiskBackend(
62 directory_.path(), k10MBytes, false, cache_thread_, completion_callback_);
63 disk_cache->CreateEntry(1, &entry, completion_callback_);
64 disk_cache->OpenEntry(2, &entry, completion_callback_);
65 disk_cache->DoomEntry(3, completion_callback_);
66
67 // Pull the plug on all that.
68 EXPECT_FALSE(disk_cache->is_disabled());
69 disk_cache->Disable();
70 EXPECT_TRUE(disk_cache->is_disabled());
71
72 FlushCacheTasks();
73
74 EXPECT_EQ(NULL, entry);
75 EXPECT_EQ(4u, completion_results_.size());
76 for (std::vector<int>::const_iterator iter = completion_results_.begin();
77 iter < completion_results_.end(); ++iter) {
78 EXPECT_EQ(net::ERR_ABORTED, *iter);
79 }
80
81 // Ensure the directory can be deleted at this point.
82 EXPECT_TRUE(base::DirectoryExists(directory_.path()));
83 EXPECT_FALSE(base::IsDirectoryEmpty(directory_.path()));
84 EXPECT_TRUE(base::DeleteFile(directory_.path(), true));
85 EXPECT_FALSE(base::DirectoryExists(directory_.path()));
86 }
87
TEST_F(AppCacheDiskCacheTest,DisableAfterInitted)88 TEST_F(AppCacheDiskCacheTest, DisableAfterInitted) {
89 // Create an instance and let it fully init.
90 scoped_ptr<AppCacheDiskCache> disk_cache(new AppCacheDiskCache);
91 EXPECT_FALSE(disk_cache->is_disabled());
92 disk_cache->InitWithDiskBackend(
93 directory_.path(), k10MBytes, false, cache_thread_, completion_callback_);
94 FlushCacheTasks();
95 EXPECT_EQ(1u, completion_results_.size());
96 EXPECT_EQ(net::OK, completion_results_[0]);
97
98 // Pull the plug
99 disk_cache->Disable();
100 FlushCacheTasks();
101
102 // Ensure the directory can be deleted at this point.
103 EXPECT_TRUE(base::DirectoryExists(directory_.path()));
104 EXPECT_FALSE(base::IsDirectoryEmpty(directory_.path()));
105 EXPECT_TRUE(base::DeleteFile(directory_.path(), true));
106 EXPECT_FALSE(base::DirectoryExists(directory_.path()));
107
108 // Methods should return immediately when disabled and not invoke
109 // the callback at all.
110 AppCacheDiskCache::Entry* entry = NULL;
111 completion_results_.clear();
112 EXPECT_EQ(net::ERR_ABORTED,
113 disk_cache->CreateEntry(1, &entry, completion_callback_));
114 EXPECT_EQ(net::ERR_ABORTED,
115 disk_cache->OpenEntry(2, &entry, completion_callback_));
116 EXPECT_EQ(net::ERR_ABORTED,
117 disk_cache->DoomEntry(3, completion_callback_));
118 FlushCacheTasks();
119 EXPECT_TRUE(completion_results_.empty());
120 }
121
122 // Flaky on Android: http://crbug.com/339534
TEST_F(AppCacheDiskCacheTest,DISABLED_DisableWithEntriesOpen)123 TEST_F(AppCacheDiskCacheTest, DISABLED_DisableWithEntriesOpen) {
124 // Create an instance and let it fully init.
125 scoped_ptr<AppCacheDiskCache> disk_cache(new AppCacheDiskCache);
126 EXPECT_FALSE(disk_cache->is_disabled());
127 disk_cache->InitWithDiskBackend(
128 directory_.path(), k10MBytes, false, cache_thread_, completion_callback_);
129 FlushCacheTasks();
130 EXPECT_EQ(1u, completion_results_.size());
131 EXPECT_EQ(net::OK, completion_results_[0]);
132
133 // Note: We don't have detailed expectations of the DiskCache
134 // operations because on android it's really SimpleCache which
135 // does behave differently.
136 //
137 // What matters for the corruption handling and service reinitiazation
138 // is that the directory can be deleted after the calling Disable() method,
139 // and we do have expectations about that.
140
141 // Create/open some entries.
142 AppCacheDiskCache::Entry* entry1 = NULL;
143 AppCacheDiskCache::Entry* entry2 = NULL;
144 disk_cache->CreateEntry(1, &entry1, completion_callback_);
145 disk_cache->CreateEntry(2, &entry2, completion_callback_);
146 FlushCacheTasks();
147 EXPECT_TRUE(entry1);
148 EXPECT_TRUE(entry2);
149
150 // Write something to one of the entries and flush it.
151 const char* kData = "Hello";
152 const int kDataLen = strlen(kData) + 1;
153 scoped_refptr<net::IOBuffer> write_buf(new net::WrappedIOBuffer(kData));
154 entry1->Write(0, 0, write_buf.get(), kDataLen, completion_callback_);
155 FlushCacheTasks();
156
157 // Queue up a read and a write.
158 scoped_refptr<net::IOBuffer> read_buf = new net::IOBuffer(kDataLen);
159 entry1->Read(0, 0, read_buf.get(), kDataLen, completion_callback_);
160 entry2->Write(0, 0, write_buf.get(), kDataLen, completion_callback_);
161
162 // Pull the plug
163 disk_cache->Disable();
164 FlushCacheTasks();
165
166 // Ensure the directory can be deleted at this point.
167 EXPECT_TRUE(base::DirectoryExists(directory_.path()));
168 EXPECT_FALSE(base::IsDirectoryEmpty(directory_.path()));
169 EXPECT_TRUE(base::DeleteFile(directory_.path(), true));
170 EXPECT_FALSE(base::DirectoryExists(directory_.path()));
171
172 disk_cache.reset(NULL);
173
174 // Also, new IO operations should fail immediately.
175 EXPECT_EQ(
176 net::ERR_ABORTED,
177 entry1->Read(0, 0, read_buf.get(), kDataLen, completion_callback_));
178 entry1->Close();
179 entry2->Close();
180
181 FlushCacheTasks();
182 }
183
184 } // namespace content
185