1 // Copyright (c) 2012 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 <map> 6 #include <set> 7 8 #include "base/bind.h" 9 #include "base/message_loop/message_loop.h" 10 #include "base/message_loop/message_loop_proxy.h" 11 #include "net/base/net_errors.h" 12 #include "testing/gtest/include/gtest/gtest.h" 13 #include "webkit/browser/appcache/appcache_quota_client.h" 14 #include "webkit/browser/appcache/mock_appcache_service.h" 15 16 namespace appcache { 17 18 // Declared to shorten the line lengths. 19 static const quota::StorageType kTemp = quota::kStorageTypeTemporary; 20 static const quota::StorageType kPerm = quota::kStorageTypePersistent; 21 22 // Base class for our test fixtures. 23 class AppCacheQuotaClientTest : public testing::Test { 24 public: 25 const GURL kOriginA; 26 const GURL kOriginB; 27 const GURL kOriginOther; 28 29 AppCacheQuotaClientTest() 30 : kOriginA("http://host"), 31 kOriginB("http://host:8000"), 32 kOriginOther("http://other"), 33 usage_(0), 34 delete_status_(quota::kQuotaStatusUnknown), 35 num_get_origin_usage_completions_(0), 36 num_get_origins_completions_(0), 37 num_delete_origins_completions_(0), 38 weak_factory_(this) { 39 } 40 41 int64 GetOriginUsage( 42 quota::QuotaClient* client, 43 const GURL& origin, 44 quota::StorageType type) { 45 usage_ = -1; 46 AsyncGetOriginUsage(client, origin, type); 47 base::MessageLoop::current()->RunUntilIdle(); 48 return usage_; 49 } 50 51 const std::set<GURL>& GetOriginsForType( 52 quota::QuotaClient* client, 53 quota::StorageType type) { 54 origins_.clear(); 55 AsyncGetOriginsForType(client, type); 56 base::MessageLoop::current()->RunUntilIdle(); 57 return origins_; 58 } 59 60 const std::set<GURL>& GetOriginsForHost( 61 quota::QuotaClient* client, 62 quota::StorageType type, 63 const std::string& host) { 64 origins_.clear(); 65 AsyncGetOriginsForHost(client, type, host); 66 base::MessageLoop::current()->RunUntilIdle(); 67 return origins_; 68 } 69 70 quota::QuotaStatusCode DeleteOriginData( 71 quota::QuotaClient* client, 72 quota::StorageType type, 73 const GURL& origin) { 74 delete_status_ = quota::kQuotaStatusUnknown; 75 AsyncDeleteOriginData(client, type, origin); 76 base::MessageLoop::current()->RunUntilIdle(); 77 return delete_status_; 78 } 79 80 void AsyncGetOriginUsage( 81 quota::QuotaClient* client, 82 const GURL& origin, 83 quota::StorageType type) { 84 client->GetOriginUsage( 85 origin, type, 86 base::Bind(&AppCacheQuotaClientTest::OnGetOriginUsageComplete, 87 weak_factory_.GetWeakPtr())); 88 } 89 90 void AsyncGetOriginsForType( 91 quota::QuotaClient* client, 92 quota::StorageType type) { 93 client->GetOriginsForType( 94 type, 95 base::Bind(&AppCacheQuotaClientTest::OnGetOriginsComplete, 96 weak_factory_.GetWeakPtr())); 97 } 98 99 void AsyncGetOriginsForHost( 100 quota::QuotaClient* client, 101 quota::StorageType type, 102 const std::string& host) { 103 client->GetOriginsForHost( 104 type, host, 105 base::Bind(&AppCacheQuotaClientTest::OnGetOriginsComplete, 106 weak_factory_.GetWeakPtr())); 107 } 108 109 void AsyncDeleteOriginData( 110 quota::QuotaClient* client, 111 quota::StorageType type, 112 const GURL& origin) { 113 client->DeleteOriginData( 114 origin, type, 115 base::Bind(&AppCacheQuotaClientTest::OnDeleteOriginDataComplete, 116 weak_factory_.GetWeakPtr())); 117 } 118 119 void SetUsageMapEntry(const GURL& origin, int64 usage) { 120 mock_service_.storage()->usage_map_[origin] = usage; 121 } 122 123 AppCacheQuotaClient* CreateClient() { 124 return new AppCacheQuotaClient(&mock_service_); 125 } 126 127 void Call_NotifyAppCacheReady(AppCacheQuotaClient* client) { 128 client->NotifyAppCacheReady(); 129 } 130 131 void Call_NotifyAppCacheDestroyed(AppCacheQuotaClient* client) { 132 client->NotifyAppCacheDestroyed(); 133 } 134 135 void Call_OnQuotaManagerDestroyed(AppCacheQuotaClient* client) { 136 client->OnQuotaManagerDestroyed(); 137 } 138 139 protected: 140 void OnGetOriginUsageComplete(int64 usage) { 141 ++num_get_origin_usage_completions_; 142 usage_ = usage; 143 } 144 145 void OnGetOriginsComplete(const std::set<GURL>& origins) { 146 ++num_get_origins_completions_; 147 origins_ = origins; 148 } 149 150 void OnDeleteOriginDataComplete(quota::QuotaStatusCode status) { 151 ++num_delete_origins_completions_; 152 delete_status_ = status; 153 } 154 155 base::MessageLoop message_loop_; 156 int64 usage_; 157 std::set<GURL> origins_; 158 quota::QuotaStatusCode delete_status_; 159 int num_get_origin_usage_completions_; 160 int num_get_origins_completions_; 161 int num_delete_origins_completions_; 162 MockAppCacheService mock_service_; 163 base::WeakPtrFactory<AppCacheQuotaClientTest> weak_factory_; 164 }; 165 166 167 TEST_F(AppCacheQuotaClientTest, BasicCreateDestroy) { 168 AppCacheQuotaClient* client = CreateClient(); 169 Call_NotifyAppCacheReady(client); 170 Call_OnQuotaManagerDestroyed(client); 171 Call_NotifyAppCacheDestroyed(client); 172 } 173 174 TEST_F(AppCacheQuotaClientTest, EmptyService) { 175 AppCacheQuotaClient* client = CreateClient(); 176 Call_NotifyAppCacheReady(client); 177 178 EXPECT_EQ(0, GetOriginUsage(client, kOriginA, kTemp)); 179 EXPECT_EQ(0, GetOriginUsage(client, kOriginA, kPerm)); 180 EXPECT_TRUE(GetOriginsForType(client, kTemp).empty()); 181 EXPECT_TRUE(GetOriginsForType(client, kPerm).empty()); 182 EXPECT_TRUE(GetOriginsForHost(client, kTemp, kOriginA.host()).empty()); 183 EXPECT_TRUE(GetOriginsForHost(client, kPerm, kOriginA.host()).empty()); 184 EXPECT_EQ(quota::kQuotaStatusOk, DeleteOriginData(client, kTemp, kOriginA)); 185 EXPECT_EQ(quota::kQuotaStatusOk, DeleteOriginData(client, kPerm, kOriginA)); 186 187 Call_NotifyAppCacheDestroyed(client); 188 Call_OnQuotaManagerDestroyed(client); 189 } 190 191 TEST_F(AppCacheQuotaClientTest, NoService) { 192 AppCacheQuotaClient* client = CreateClient(); 193 Call_NotifyAppCacheReady(client); 194 Call_NotifyAppCacheDestroyed(client); 195 196 EXPECT_EQ(0, GetOriginUsage(client, kOriginA, kTemp)); 197 EXPECT_EQ(0, GetOriginUsage(client, kOriginA, kPerm)); 198 EXPECT_TRUE(GetOriginsForType(client, kTemp).empty()); 199 EXPECT_TRUE(GetOriginsForType(client, kPerm).empty()); 200 EXPECT_TRUE(GetOriginsForHost(client, kTemp, kOriginA.host()).empty()); 201 EXPECT_TRUE(GetOriginsForHost(client, kPerm, kOriginA.host()).empty()); 202 EXPECT_EQ(quota::kQuotaErrorAbort, 203 DeleteOriginData(client, kTemp, kOriginA)); 204 EXPECT_EQ(quota::kQuotaErrorAbort, 205 DeleteOriginData(client, kPerm, kOriginA)); 206 207 Call_OnQuotaManagerDestroyed(client); 208 } 209 210 TEST_F(AppCacheQuotaClientTest, GetOriginUsage) { 211 AppCacheQuotaClient* client = CreateClient(); 212 Call_NotifyAppCacheReady(client); 213 214 SetUsageMapEntry(kOriginA, 1000); 215 EXPECT_EQ(1000, GetOriginUsage(client, kOriginA, kTemp)); 216 EXPECT_EQ(0, GetOriginUsage(client, kOriginA, kPerm)); 217 218 Call_NotifyAppCacheDestroyed(client); 219 Call_OnQuotaManagerDestroyed(client); 220 } 221 222 TEST_F(AppCacheQuotaClientTest, GetOriginsForHost) { 223 AppCacheQuotaClient* client = CreateClient(); 224 Call_NotifyAppCacheReady(client); 225 226 EXPECT_EQ(kOriginA.host(), kOriginB.host()); 227 EXPECT_NE(kOriginA.host(), kOriginOther.host()); 228 229 std::set<GURL> origins = GetOriginsForHost(client, kTemp, kOriginA.host()); 230 EXPECT_TRUE(origins.empty()); 231 232 SetUsageMapEntry(kOriginA, 1000); 233 SetUsageMapEntry(kOriginB, 10); 234 SetUsageMapEntry(kOriginOther, 500); 235 236 origins = GetOriginsForHost(client, kTemp, kOriginA.host()); 237 EXPECT_EQ(2ul, origins.size()); 238 EXPECT_TRUE(origins.find(kOriginA) != origins.end()); 239 EXPECT_TRUE(origins.find(kOriginB) != origins.end()); 240 241 origins = GetOriginsForHost(client, kTemp, kOriginOther.host()); 242 EXPECT_EQ(1ul, origins.size()); 243 EXPECT_TRUE(origins.find(kOriginOther) != origins.end()); 244 245 origins = GetOriginsForHost(client, kPerm, kOriginA.host()); 246 EXPECT_TRUE(origins.empty()); 247 248 Call_NotifyAppCacheDestroyed(client); 249 Call_OnQuotaManagerDestroyed(client); 250 } 251 252 TEST_F(AppCacheQuotaClientTest, GetOriginsForType) { 253 AppCacheQuotaClient* client = CreateClient(); 254 Call_NotifyAppCacheReady(client); 255 256 EXPECT_TRUE(GetOriginsForType(client, kTemp).empty()); 257 EXPECT_TRUE(GetOriginsForType(client, kPerm).empty()); 258 259 SetUsageMapEntry(kOriginA, 1000); 260 SetUsageMapEntry(kOriginB, 10); 261 262 std::set<GURL> origins = GetOriginsForType(client, kTemp); 263 EXPECT_EQ(2ul, origins.size()); 264 EXPECT_TRUE(origins.find(kOriginA) != origins.end()); 265 EXPECT_TRUE(origins.find(kOriginB) != origins.end()); 266 267 EXPECT_TRUE(GetOriginsForType(client, kPerm).empty()); 268 269 Call_NotifyAppCacheDestroyed(client); 270 Call_OnQuotaManagerDestroyed(client); 271 } 272 273 TEST_F(AppCacheQuotaClientTest, DeleteOriginData) { 274 AppCacheQuotaClient* client = CreateClient(); 275 Call_NotifyAppCacheReady(client); 276 277 // Perm deletions are short circuited in the Client and 278 // should not reach the AppCacheService. 279 EXPECT_EQ(quota::kQuotaStatusOk, 280 DeleteOriginData(client, kPerm, kOriginA)); 281 EXPECT_EQ(0, mock_service_.delete_called_count()); 282 283 EXPECT_EQ(quota::kQuotaStatusOk, 284 DeleteOriginData(client, kTemp, kOriginA)); 285 EXPECT_EQ(1, mock_service_.delete_called_count()); 286 287 mock_service_.set_mock_delete_appcaches_for_origin_result( 288 net::ERR_ABORTED); 289 EXPECT_EQ(quota::kQuotaErrorAbort, 290 DeleteOriginData(client, kTemp, kOriginA)); 291 EXPECT_EQ(2, mock_service_.delete_called_count()); 292 293 Call_OnQuotaManagerDestroyed(client); 294 Call_NotifyAppCacheDestroyed(client); 295 } 296 297 TEST_F(AppCacheQuotaClientTest, PendingRequests) { 298 AppCacheQuotaClient* client = CreateClient(); 299 300 SetUsageMapEntry(kOriginA, 1000); 301 SetUsageMapEntry(kOriginB, 10); 302 SetUsageMapEntry(kOriginOther, 500); 303 304 // Queue up some reqeusts. 305 AsyncGetOriginUsage(client, kOriginA, kPerm); 306 AsyncGetOriginUsage(client, kOriginB, kTemp); 307 AsyncGetOriginsForType(client, kPerm); 308 AsyncGetOriginsForType(client, kTemp); 309 AsyncGetOriginsForHost(client, kTemp, kOriginA.host()); 310 AsyncGetOriginsForHost(client, kTemp, kOriginOther.host()); 311 AsyncDeleteOriginData(client, kTemp, kOriginA); 312 AsyncDeleteOriginData(client, kPerm, kOriginA); 313 AsyncDeleteOriginData(client, kTemp, kOriginB); 314 315 EXPECT_EQ(0, num_get_origin_usage_completions_); 316 EXPECT_EQ(0, num_get_origins_completions_); 317 EXPECT_EQ(0, num_delete_origins_completions_); 318 base::MessageLoop::current()->RunUntilIdle(); 319 EXPECT_EQ(0, num_get_origin_usage_completions_); 320 EXPECT_EQ(0, num_get_origins_completions_); 321 EXPECT_EQ(0, num_delete_origins_completions_); 322 323 // Pending requests should get serviced when the appcache is ready. 324 Call_NotifyAppCacheReady(client); 325 EXPECT_EQ(2, num_get_origin_usage_completions_); 326 EXPECT_EQ(4, num_get_origins_completions_); 327 EXPECT_EQ(0, num_delete_origins_completions_); 328 base::MessageLoop::current()->RunUntilIdle(); 329 EXPECT_EQ(3, num_delete_origins_completions_); // deletes are really async 330 331 // They should be serviced in order requested. 332 EXPECT_EQ(10, usage_); 333 EXPECT_EQ(1ul, origins_.size()); 334 EXPECT_TRUE(origins_.find(kOriginOther) != origins_.end()); 335 336 Call_NotifyAppCacheDestroyed(client); 337 Call_OnQuotaManagerDestroyed(client); 338 } 339 340 TEST_F(AppCacheQuotaClientTest, DestroyServiceWithPending) { 341 AppCacheQuotaClient* client = CreateClient(); 342 343 SetUsageMapEntry(kOriginA, 1000); 344 SetUsageMapEntry(kOriginB, 10); 345 SetUsageMapEntry(kOriginOther, 500); 346 347 // Queue up some reqeusts prior to being ready. 348 AsyncGetOriginUsage(client, kOriginA, kPerm); 349 AsyncGetOriginUsage(client, kOriginB, kTemp); 350 AsyncGetOriginsForType(client, kPerm); 351 AsyncGetOriginsForType(client, kTemp); 352 AsyncGetOriginsForHost(client, kTemp, kOriginA.host()); 353 AsyncGetOriginsForHost(client, kTemp, kOriginOther.host()); 354 AsyncDeleteOriginData(client, kTemp, kOriginA); 355 AsyncDeleteOriginData(client, kPerm, kOriginA); 356 AsyncDeleteOriginData(client, kTemp, kOriginB); 357 base::MessageLoop::current()->RunUntilIdle(); 358 EXPECT_EQ(0, num_get_origin_usage_completions_); 359 EXPECT_EQ(0, num_get_origins_completions_); 360 EXPECT_EQ(0, num_delete_origins_completions_); 361 362 // Kill the service. 363 Call_NotifyAppCacheDestroyed(client); 364 365 // All should have been aborted and called completion. 366 EXPECT_EQ(2, num_get_origin_usage_completions_); 367 EXPECT_EQ(4, num_get_origins_completions_); 368 EXPECT_EQ(3, num_delete_origins_completions_); 369 EXPECT_EQ(0, usage_); 370 EXPECT_TRUE(origins_.empty()); 371 EXPECT_EQ(quota::kQuotaErrorAbort, delete_status_); 372 373 Call_OnQuotaManagerDestroyed(client); 374 } 375 376 TEST_F(AppCacheQuotaClientTest, DestroyQuotaManagerWithPending) { 377 AppCacheQuotaClient* client = CreateClient(); 378 379 SetUsageMapEntry(kOriginA, 1000); 380 SetUsageMapEntry(kOriginB, 10); 381 SetUsageMapEntry(kOriginOther, 500); 382 383 // Queue up some reqeusts prior to being ready. 384 AsyncGetOriginUsage(client, kOriginA, kPerm); 385 AsyncGetOriginUsage(client, kOriginB, kTemp); 386 AsyncGetOriginsForType(client, kPerm); 387 AsyncGetOriginsForType(client, kTemp); 388 AsyncGetOriginsForHost(client, kTemp, kOriginA.host()); 389 AsyncGetOriginsForHost(client, kTemp, kOriginOther.host()); 390 AsyncDeleteOriginData(client, kTemp, kOriginA); 391 AsyncDeleteOriginData(client, kPerm, kOriginA); 392 AsyncDeleteOriginData(client, kTemp, kOriginB); 393 base::MessageLoop::current()->RunUntilIdle(); 394 EXPECT_EQ(0, num_get_origin_usage_completions_); 395 EXPECT_EQ(0, num_get_origins_completions_); 396 EXPECT_EQ(0, num_delete_origins_completions_); 397 398 // Kill the quota manager. 399 Call_OnQuotaManagerDestroyed(client); 400 Call_NotifyAppCacheReady(client); 401 402 // Callbacks should be deleted and not called. 403 base::MessageLoop::current()->RunUntilIdle(); 404 EXPECT_EQ(0, num_get_origin_usage_completions_); 405 EXPECT_EQ(0, num_get_origins_completions_); 406 EXPECT_EQ(0, num_delete_origins_completions_); 407 408 Call_NotifyAppCacheDestroyed(client); 409 } 410 411 TEST_F(AppCacheQuotaClientTest, DestroyWithDeleteInProgress) { 412 AppCacheQuotaClient* client = CreateClient(); 413 Call_NotifyAppCacheReady(client); 414 415 // Start an async delete. 416 AsyncDeleteOriginData(client, kTemp, kOriginB); 417 EXPECT_EQ(0, num_delete_origins_completions_); 418 419 // Kill the service. 420 Call_NotifyAppCacheDestroyed(client); 421 422 // Should have been aborted. 423 EXPECT_EQ(1, num_delete_origins_completions_); 424 EXPECT_EQ(quota::kQuotaErrorAbort, delete_status_); 425 426 // A real completion callback from the service should 427 // be dropped if it comes in after NotifyAppCacheDestroyed. 428 base::MessageLoop::current()->RunUntilIdle(); 429 EXPECT_EQ(1, num_delete_origins_completions_); 430 EXPECT_EQ(quota::kQuotaErrorAbort, delete_status_); 431 432 Call_OnQuotaManagerDestroyed(client); 433 } 434 435 } // namespace appcache 436
