content/browser/database_tracker_unittest.cc

   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/file_util.h"
   6 #include "base/files/file.h"
   7 #include "base/files/file_path.h"
   8 #include "base/files/scoped_temp_dir.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/message_loop/message_loop_proxy.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "base/time/time.h"
  14 #include "content/public/test/mock_special_storage_policy.h"
  15 #include "net/base/net_errors.h"
  16 #include "net/base/test_completion_callback.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18 #include "third_party/sqlite/sqlite3.h"
  19 #include "webkit/browser/database/database_tracker.h"
  20 #include "webkit/browser/quota/quota_manager_proxy.h"
  21 #include "webkit/common/database/database_identifier.h"
  22
  23 using base::ASCIIToUTF16;
  24 using webkit_database::DatabaseConnections;
  25 using webkit_database::DatabaseTracker;
  26 using webkit_database::OriginInfo;
  27
  28 namespace {
  29
  30 const char kOrigin1Url[] = "http://origin1";
  31 const char kOrigin2Url[] = "http://protected_origin2";
  32
  33 class TestObserver : public webkit_database::DatabaseTracker::Observer {
  34  public:
  35   TestObserver()
  36       : new_notification_received_(false),
  37         observe_size_changes_(true),
  38         observe_scheduled_deletions_(true) {
  39   }
  40   TestObserver(bool observe_size_changes, bool observe_scheduled_deletions)
  41       : new_notification_received_(false),
  42         observe_size_changes_(observe_size_changes),
  43         observe_scheduled_deletions_(observe_scheduled_deletions) {
  44   }
  45
  46   virtual ~TestObserver() {}
  47   virtual void OnDatabaseSizeChanged(const std::string& origin_identifier,
  48                                      const base::string16& database_name,
  49                                      int64 database_size) OVERRIDE {
  50     if (!observe_size_changes_)
  51       return;
  52     new_notification_received_ = true;
  53     origin_identifier_ = origin_identifier;
  54     database_name_ = database_name;
  55     database_size_ = database_size;
  56   }
  57   virtual void OnDatabaseScheduledForDeletion(
  58       const std::string& origin_identifier,
  59       const base::string16& database_name) OVERRIDE {
  60     if (!observe_scheduled_deletions_)
  61       return;
  62     new_notification_received_ = true;
  63     origin_identifier_ = origin_identifier;
  64     database_name_ = database_name;
  65   }
  66   bool DidReceiveNewNotification() {
  67     bool temp_new_notification_received = new_notification_received_;
  68     new_notification_received_ = false;
  69     return temp_new_notification_received;
  70   }
  71   std::string GetNotificationOriginIdentifier() {
  72     return origin_identifier_;
  73   }
  74   base::string16 GetNotificationDatabaseName() { return database_name_; }
  75   int64 GetNotificationDatabaseSize() { return database_size_; }
  76
  77  private:
  78   bool new_notification_received_;
  79   bool observe_size_changes_;
  80   bool observe_scheduled_deletions_;
  81   std::string origin_identifier_;
  82   base::string16 database_name_;
  83   int64 database_size_;
  84 };
  85
  86 void CheckNotificationReceived(TestObserver* observer,
  87                                const std::string& expected_origin_identifier,
  88                                const base::string16& expected_database_name,
  89                                int64 expected_database_size) {
  90   EXPECT_TRUE(observer->DidReceiveNewNotification());
  91   EXPECT_EQ(expected_origin_identifier,
  92             observer->GetNotificationOriginIdentifier());
  93   EXPECT_EQ(expected_database_name,
  94             observer->GetNotificationDatabaseName());
  95   EXPECT_EQ(expected_database_size,
  96             observer->GetNotificationDatabaseSize());
  97 }
  98
  99 class TestQuotaManagerProxy : public quota::QuotaManagerProxy {
 100  public:
 101   TestQuotaManagerProxy()
 102       : QuotaManagerProxy(NULL, NULL),
 103         registered_client_(NULL) {
 104   }
 105
 106   virtual void RegisterClient(quota::QuotaClient* client) OVERRIDE {
 107     EXPECT_FALSE(registered_client_);
 108     registered_client_ = client;
 109   }
 110
 111   virtual void NotifyStorageAccessed(quota::QuotaClient::ID client_id,
 112                                      const GURL& origin,
 113                                      quota::StorageType type) OVERRIDE {
 114     EXPECT_EQ(quota::QuotaClient::kDatabase, client_id);
 115     EXPECT_EQ(quota::kStorageTypeTemporary, type);
 116     accesses_[origin] += 1;
 117   }
 118
 119   virtual void NotifyStorageModified(quota::QuotaClient::ID client_id,
 120                                      const GURL& origin,
 121                                      quota::StorageType type,
 122                                      int64 delta) OVERRIDE {
 123     EXPECT_EQ(quota::QuotaClient::kDatabase, client_id);
 124     EXPECT_EQ(quota::kStorageTypeTemporary, type);
 125     modifications_[origin].first += 1;
 126     modifications_[origin].second += delta;
 127   }
 128
 129   // Not needed for our tests.
 130   virtual void NotifyOriginInUse(const GURL& origin) OVERRIDE {}
 131   virtual void NotifyOriginNoLongerInUse(const GURL& origin) OVERRIDE {}
 132   virtual void SetUsageCacheEnabled(quota::QuotaClient::ID client_id,
 133                                     const GURL& origin,
 134                                     quota::StorageType type,
 135                                     bool enabled) OVERRIDE {}
 136   virtual void GetUsageAndQuota(
 137       base::SequencedTaskRunner* original_task_runner,
 138       const GURL& origin,
 139       quota::StorageType type,
 140       const GetUsageAndQuotaCallback& callback) OVERRIDE {}
 141
 142   void SimulateQuotaManagerDestroyed() {
 143     if (registered_client_) {
 144       registered_client_->OnQuotaManagerDestroyed();
 145       registered_client_ = NULL;
 146     }
 147   }
 148
 149   bool WasAccessNotified(const GURL& origin) {
 150     return accesses_[origin] != 0;
 151   }
 152
 153   bool WasModificationNotified(const GURL& origin, int64 amount) {
 154     return modifications_[origin].first != 0 &&
 155            modifications_[origin].second == amount;
 156   }
 157
 158   void reset() {
 159     accesses_.clear();
 160     modifications_.clear();
 161   }
 162
 163   quota::QuotaClient* registered_client_;
 164
 165   // Map from origin to count of access notifications.
 166   std::map<GURL, int> accesses_;
 167
 168   // Map from origin to <count, sum of deltas>
 169   std::map<GURL, std::pair<int, int64> > modifications_;
 170
 171  protected:
 172   virtual ~TestQuotaManagerProxy() {
 173     EXPECT_FALSE(registered_client_);
 174   }
 175 };
 176
 177
 178 bool EnsureFileOfSize(const base::FilePath& file_path, int64 length) {
 179   base::File file(file_path,
 180                   base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_WRITE);
 181   if (!file.IsValid())
 182     return false;
 183   return file.SetLength(length);
 184 }
 185
 186 }  // namespace
 187
 188 namespace content {
 189
 190 // We declare a helper class, and make it a friend of DatabaseTracker using
 191 // the FORWARD_DECLARE_TEST macro, and we implement all tests we want to run as
 192 // static methods of this class. Then we make our TEST() targets call these
 193 // static functions. This allows us to run each test in normal mode and
 194 // incognito mode without writing the same code twice.
 195 class DatabaseTracker_TestHelper_Test {
 196  public:
 197   static void TestDeleteOpenDatabase(bool incognito_mode) {
 198     // Initialize the tracker database.
 199     base::ScopedTempDir temp_dir;
 200     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 201     scoped_refptr<MockSpecialStoragePolicy> special_storage_policy =
 202         new MockSpecialStoragePolicy;
 203     special_storage_policy->AddProtected(GURL(kOrigin2Url));
 204     scoped_refptr<DatabaseTracker> tracker(
 205         new DatabaseTracker(temp_dir.path(),
 206                             incognito_mode,
 207                             special_storage_policy.get(),
 208                             NULL,
 209                             NULL));
 210
 211     // Create and open three databases.
 212     int64 database_size = 0;
 213     const std::string kOrigin1 =
 214         webkit_database::GetIdentifierFromOrigin(GURL(kOrigin1Url));
 215     const std::string kOrigin2 =
 216         webkit_database::GetIdentifierFromOrigin(GURL(kOrigin2Url));
 217     const base::string16 kDB1 = ASCIIToUTF16("db1");
 218     const base::string16 kDB2 = ASCIIToUTF16("db2");
 219     const base::string16 kDB3 = ASCIIToUTF16("db3");
 220     const base::string16 kDescription = ASCIIToUTF16("database_description");
 221
 222     tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
 223                             &database_size);
 224     tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
 225                             &database_size);
 226     tracker->DatabaseOpened(kOrigin2, kDB3, kDescription, 0,
 227                             &database_size);
 228
 229     EXPECT_TRUE(base::CreateDirectory(
 230         tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
 231             tracker->GetOriginDirectory(kOrigin1)))));
 232     EXPECT_TRUE(base::CreateDirectory(
 233         tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
 234             tracker->GetOriginDirectory(kOrigin2)))));
 235     EXPECT_EQ(1, base::WriteFile(
 236         tracker->GetFullDBFilePath(kOrigin1, kDB1), "a", 1));
 237     EXPECT_EQ(2, base::WriteFile(
 238         tracker->GetFullDBFilePath(kOrigin2, kDB2), "aa", 2));
 239     EXPECT_EQ(3, base::WriteFile(
 240         tracker->GetFullDBFilePath(kOrigin2, kDB3), "aaa", 3));
 241     tracker->DatabaseModified(kOrigin1, kDB1);
 242     tracker->DatabaseModified(kOrigin2, kDB2);
 243     tracker->DatabaseModified(kOrigin2, kDB3);
 244
 245     // Delete db1. Should also delete origin1.
 246     TestObserver observer;
 247     tracker->AddObserver(&observer);
 248     net::TestCompletionCallback callback;
 249     int result = tracker->DeleteDatabase(kOrigin1, kDB1, callback.callback());
 250     EXPECT_EQ(net::ERR_IO_PENDING, result);
 251     ASSERT_FALSE(callback.have_result());
 252     EXPECT_TRUE(observer.DidReceiveNewNotification());
 253     EXPECT_EQ(kOrigin1, observer.GetNotificationOriginIdentifier());
 254     EXPECT_EQ(kDB1, observer.GetNotificationDatabaseName());
 255     tracker->DatabaseClosed(kOrigin1, kDB1);
 256     result = callback.GetResult(result);
 257     EXPECT_EQ(net::OK, result);
 258     EXPECT_FALSE(base::PathExists(
 259           tracker->DatabaseDirectory().AppendASCII(kOrigin1)));
 260
 261     // Recreate db1.
 262     tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
 263                             &database_size);
 264     EXPECT_TRUE(base::CreateDirectory(
 265         tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
 266             tracker->GetOriginDirectory(kOrigin1)))));
 267     EXPECT_EQ(1, base::WriteFile(
 268         tracker->GetFullDBFilePath(kOrigin1, kDB1), "a", 1));
 269     tracker->DatabaseModified(kOrigin1, kDB1);
 270
 271     // Setup file modification times.  db1 and db2 are modified now, db3 three
 272     // days ago.
 273     base::Time now = base::Time::Now();
 274     EXPECT_TRUE(base::TouchFile(tracker->GetFullDBFilePath(kOrigin1, kDB1),
 275                                 now, now));
 276     EXPECT_TRUE(base::TouchFile(tracker->GetFullDBFilePath(kOrigin2, kDB2),
 277                                 now, now));
 278     base::Time three_days_ago = now - base::TimeDelta::FromDays(3);
 279     EXPECT_TRUE(base::TouchFile(tracker->GetFullDBFilePath(kOrigin2, kDB3),
 280                                 three_days_ago, three_days_ago));
 281
 282     // Delete databases modified since yesterday. db2 is whitelisted.
 283     base::Time yesterday = base::Time::Now();
 284     yesterday -= base::TimeDelta::FromDays(1);
 285     result = tracker->DeleteDataModifiedSince(
 286         yesterday, callback.callback());
 287     EXPECT_EQ(net::ERR_IO_PENDING, result);
 288     ASSERT_FALSE(callback.have_result());
 289     EXPECT_TRUE(observer.DidReceiveNewNotification());
 290     tracker->DatabaseClosed(kOrigin1, kDB1);
 291     tracker->DatabaseClosed(kOrigin2, kDB2);
 292     result = callback.GetResult(result);
 293     EXPECT_EQ(net::OK, result);
 294     EXPECT_FALSE(base::PathExists(
 295         tracker->DatabaseDirectory().AppendASCII(kOrigin1)));
 296     EXPECT_TRUE(
 297         base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB2)));
 298     EXPECT_TRUE(
 299         base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB3)));
 300
 301     tracker->DatabaseClosed(kOrigin2, kDB3);
 302     tracker->RemoveObserver(&observer);
 303   }
 304
 305   static void TestDatabaseTracker(bool incognito_mode) {
 306     // Initialize the tracker database.
 307     base::ScopedTempDir temp_dir;
 308     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 309     scoped_refptr<MockSpecialStoragePolicy> special_storage_policy =
 310         new MockSpecialStoragePolicy;
 311     special_storage_policy->AddProtected(GURL(kOrigin2Url));
 312     scoped_refptr<DatabaseTracker> tracker(
 313         new DatabaseTracker(temp_dir.path(),
 314                             incognito_mode,
 315                             special_storage_policy.get(),
 316                             NULL,
 317                             NULL));
 318
 319     // Add two observers.
 320     TestObserver observer1;
 321     TestObserver observer2;
 322     tracker->AddObserver(&observer1);
 323     tracker->AddObserver(&observer2);
 324
 325     // Open three new databases.
 326     int64 database_size = 0;
 327     const std::string kOrigin1 =
 328         webkit_database::GetIdentifierFromOrigin(GURL(kOrigin1Url));
 329     const std::string kOrigin2 =
 330         webkit_database::GetIdentifierFromOrigin(GURL(kOrigin2Url));
 331     const base::string16 kDB1 = ASCIIToUTF16("db1");
 332     const base::string16 kDB2 = ASCIIToUTF16("db2");
 333     const base::string16 kDB3 = ASCIIToUTF16("db3");
 334     const base::string16 kDescription = ASCIIToUTF16("database_description");
 335
 336     // Get the info for kOrigin1 and kOrigin2
 337     DatabaseTracker::CachedOriginInfo* origin1_info =
 338         tracker->GetCachedOriginInfo(kOrigin1);
 339     DatabaseTracker::CachedOriginInfo* origin2_info =
 340         tracker->GetCachedOriginInfo(kOrigin1);
 341     EXPECT_TRUE(origin1_info);
 342     EXPECT_TRUE(origin2_info);
 343
 344
 345     tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
 346                             &database_size);
 347     EXPECT_EQ(0, database_size);
 348     tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
 349                             &database_size);
 350     EXPECT_EQ(0, database_size);
 351     tracker->DatabaseOpened(kOrigin1, kDB3, kDescription, 0,
 352                             &database_size);
 353     EXPECT_EQ(0, database_size);
 354
 355     // Write some data to each file and check that the listeners are
 356     // called with the appropriate values.
 357     EXPECT_TRUE(base::CreateDirectory(
 358         tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
 359             tracker->GetOriginDirectory(kOrigin1)))));
 360     EXPECT_TRUE(base::CreateDirectory(
 361         tracker->DatabaseDirectory().Append(base::FilePath::FromUTF16Unsafe(
 362             tracker->GetOriginDirectory(kOrigin2)))));
 363     EXPECT_EQ(1, base::WriteFile(
 364         tracker->GetFullDBFilePath(kOrigin1, kDB1), "a", 1));
 365     EXPECT_EQ(2, base::WriteFile(
 366         tracker->GetFullDBFilePath(kOrigin2, kDB2), "aa", 2));
 367     EXPECT_EQ(4, base::WriteFile(
 368         tracker->GetFullDBFilePath(kOrigin1, kDB3), "aaaa", 4));
 369     tracker->DatabaseModified(kOrigin1, kDB1);
 370     CheckNotificationReceived(&observer1, kOrigin1, kDB1, 1);
 371     CheckNotificationReceived(&observer2, kOrigin1, kDB1, 1);
 372     tracker->DatabaseModified(kOrigin2, kDB2);
 373     CheckNotificationReceived(&observer1, kOrigin2, kDB2, 2);
 374     CheckNotificationReceived(&observer2, kOrigin2, kDB2, 2);
 375     tracker->DatabaseModified(kOrigin1, kDB3);
 376     CheckNotificationReceived(&observer1, kOrigin1, kDB3, 4);
 377     CheckNotificationReceived(&observer2, kOrigin1, kDB3, 4);
 378
 379     // Close all databases
 380     tracker->DatabaseClosed(kOrigin1, kDB1);
 381     tracker->DatabaseClosed(kOrigin2, kDB2);
 382     tracker->DatabaseClosed(kOrigin1, kDB3);
 383
 384     // Open an existing database and check the reported size
 385     tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
 386                             &database_size);
 387     EXPECT_EQ(1, database_size);
 388     tracker->DatabaseClosed(kOrigin1, kDB1);
 389
 390     // Remove an observer; this should clear all caches.
 391     tracker->RemoveObserver(&observer2);
 392
 393     // Close the tracker database and clear all caches.
 394     // Then make sure that DatabaseOpened() still returns the correct result.
 395     tracker->CloseTrackerDatabaseAndClearCaches();
 396     tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
 397                             &database_size);
 398     EXPECT_EQ(1, database_size);
 399     tracker->DatabaseClosed(kOrigin1, kDB1);
 400
 401     // Remove all observers.
 402     tracker->RemoveObserver(&observer1);
 403
 404     // Trying to delete a database in use should fail
 405     tracker->DatabaseOpened(kOrigin1, kDB3, kDescription, 0,
 406                             &database_size);
 407     EXPECT_FALSE(tracker->DeleteClosedDatabase(kOrigin1, kDB3));
 408     origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
 409     EXPECT_TRUE(origin1_info);
 410     EXPECT_EQ(4, origin1_info->GetDatabaseSize(kDB3));
 411     tracker->DatabaseClosed(kOrigin1, kDB3);
 412
 413     // Delete a database and make sure the space used by that origin is updated
 414     EXPECT_TRUE(tracker->DeleteClosedDatabase(kOrigin1, kDB3));
 415     origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
 416     EXPECT_TRUE(origin1_info);
 417     EXPECT_EQ(1, origin1_info->GetDatabaseSize(kDB1));
 418     EXPECT_EQ(0, origin1_info->GetDatabaseSize(kDB3));
 419
 420     // Get all data for all origins
 421     std::vector<OriginInfo> origins_info;
 422     EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info));
 423     EXPECT_EQ(size_t(2), origins_info.size());
 424     EXPECT_EQ(kOrigin1, origins_info[0].GetOriginIdentifier());
 425     EXPECT_EQ(1, origins_info[0].TotalSize());
 426     EXPECT_EQ(1, origins_info[0].GetDatabaseSize(kDB1));
 427     EXPECT_EQ(0, origins_info[0].GetDatabaseSize(kDB3));
 428
 429     EXPECT_EQ(kOrigin2, origins_info[1].GetOriginIdentifier());
 430     EXPECT_EQ(2, origins_info[1].TotalSize());
 431
 432     // Trying to delete an origin with databases in use should fail
 433     tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
 434                             &database_size);
 435     EXPECT_FALSE(tracker->DeleteOrigin(kOrigin1, false));
 436     origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
 437     EXPECT_TRUE(origin1_info);
 438     EXPECT_EQ(1, origin1_info->GetDatabaseSize(kDB1));
 439     tracker->DatabaseClosed(kOrigin1, kDB1);
 440
 441     // Delete an origin that doesn't have any database in use
 442     EXPECT_TRUE(tracker->DeleteOrigin(kOrigin1, false));
 443     origins_info.clear();
 444     EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info));
 445     EXPECT_EQ(size_t(1), origins_info.size());
 446     EXPECT_EQ(kOrigin2, origins_info[0].GetOriginIdentifier());
 447
 448     origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
 449     EXPECT_TRUE(origin1_info);
 450     EXPECT_EQ(0, origin1_info->TotalSize());
 451   }
 452
 453   static void DatabaseTrackerQuotaIntegration() {
 454     const GURL kOrigin(kOrigin1Url);
 455     const std::string kOriginId =
 456         webkit_database::GetIdentifierFromOrigin(kOrigin);
 457     const base::string16 kName = ASCIIToUTF16("name");
 458     const base::string16 kDescription = ASCIIToUTF16("description");
 459
 460     base::ScopedTempDir temp_dir;
 461     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 462
 463     // Initialize the tracker with a QuotaManagerProxy
 464     scoped_refptr<TestQuotaManagerProxy> test_quota_proxy(
 465         new TestQuotaManagerProxy);
 466     scoped_refptr<DatabaseTracker> tracker(
 467         new DatabaseTracker(temp_dir.path(),
 468                             false /* incognito */,
 469                             NULL,
 470                             test_quota_proxy.get(),
 471                             NULL));
 472     EXPECT_TRUE(test_quota_proxy->registered_client_);
 473
 474     // Create a database and modify it a couple of times, close it,
 475     // then delete it. Observe the tracker notifies accordingly.
 476
 477     int64 database_size = 0;
 478     tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
 479                             &database_size);
 480     EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
 481     test_quota_proxy->reset();
 482
 483     base::FilePath db_file(tracker->GetFullDBFilePath(kOriginId, kName));
 484     EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
 485     EXPECT_TRUE(EnsureFileOfSize(db_file, 10));
 486     tracker->DatabaseModified(kOriginId, kName);
 487     EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 10));
 488     test_quota_proxy->reset();
 489
 490     EXPECT_TRUE(EnsureFileOfSize(db_file, 100));
 491     tracker->DatabaseModified(kOriginId, kName);
 492     EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 90));
 493     test_quota_proxy->reset();
 494
 495     tracker->DatabaseClosed(kOriginId, kName);
 496     EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
 497     EXPECT_EQ(net::OK, tracker->DeleteDatabase(
 498         kOriginId, kName, net::CompletionCallback()));
 499     EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, -100));
 500     test_quota_proxy->reset();
 501
 502     // Create a database and modify it, try to delete it while open,
 503     // then close it (at which time deletion will actually occur).
 504     // Observe the tracker notifies accordingly.
 505
 506     tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
 507                             &database_size);
 508     EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
 509     test_quota_proxy->reset();
 510
 511     db_file = tracker->GetFullDBFilePath(kOriginId, kName);
 512     EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
 513     EXPECT_TRUE(EnsureFileOfSize(db_file, 100));
 514     tracker->DatabaseModified(kOriginId, kName);
 515     EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
 516     test_quota_proxy->reset();
 517
 518     EXPECT_EQ(net::ERR_IO_PENDING,
 519               tracker->DeleteDatabase(kOriginId, kName,
 520                                       net::CompletionCallback()));
 521     EXPECT_FALSE(test_quota_proxy->WasModificationNotified(kOrigin, -100));
 522
 523     tracker->DatabaseClosed(kOriginId, kName);
 524     EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
 525     EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, -100));
 526     test_quota_proxy->reset();
 527
 528     // Create a database and up the file size without telling
 529     // the tracker about the modification, than simulate a
 530     // a renderer crash.
 531     // Observe the tracker notifies accordingly.
 532
 533     tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
 534                             &database_size);
 535     EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
 536     test_quota_proxy->reset();
 537     db_file = tracker->GetFullDBFilePath(kOriginId, kName);
 538     EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
 539     EXPECT_TRUE(EnsureFileOfSize(db_file, 100));
 540     DatabaseConnections crashed_renderer_connections;
 541     crashed_renderer_connections.AddConnection(kOriginId, kName);
 542     EXPECT_FALSE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
 543     tracker->CloseDatabases(crashed_renderer_connections);
 544     EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
 545
 546     // Cleanup.
 547     crashed_renderer_connections.RemoveAllConnections();
 548     test_quota_proxy->SimulateQuotaManagerDestroyed();
 549   }
 550
 551   static void DatabaseTrackerClearSessionOnlyDatabasesOnExit() {
 552     int64 database_size = 0;
 553     const std::string kOrigin1 =
 554         webkit_database::GetIdentifierFromOrigin(GURL(kOrigin1Url));
 555     const std::string kOrigin2 =
 556         webkit_database::GetIdentifierFromOrigin(GURL(kOrigin2Url));
 557     const base::string16 kDB1 = ASCIIToUTF16("db1");
 558     const base::string16 kDB2 = ASCIIToUTF16("db2");
 559     const base::string16 kDescription = ASCIIToUTF16("database_description");
 560
 561     // Initialize the tracker database.
 562     base::MessageLoop message_loop;
 563     base::ScopedTempDir temp_dir;
 564     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 565     base::FilePath origin1_db_dir;
 566     base::FilePath origin2_db_dir;
 567     {
 568       scoped_refptr<MockSpecialStoragePolicy> special_storage_policy =
 569           new MockSpecialStoragePolicy;
 570       special_storage_policy->AddSessionOnly(GURL(kOrigin2Url));
 571       scoped_refptr<DatabaseTracker> tracker(
 572           new DatabaseTracker(temp_dir.path(),
 573                               false,
 574                               special_storage_policy.get(),
 575                               NULL,
 576                               base::MessageLoopProxy::current().get()));
 577
 578       // Open two new databases.
 579       tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
 580                               &database_size);
 581       EXPECT_EQ(0, database_size);
 582       tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
 583                               &database_size);
 584       EXPECT_EQ(0, database_size);
 585
 586       // Write some data to each file.
 587       base::FilePath db_file;
 588       db_file = tracker->GetFullDBFilePath(kOrigin1, kDB1);
 589       EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
 590       EXPECT_TRUE(EnsureFileOfSize(db_file, 1));
 591
 592       db_file = tracker->GetFullDBFilePath(kOrigin2, kDB2);
 593       EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
 594       EXPECT_TRUE(EnsureFileOfSize(db_file, 2));
 595
 596       // Store the origin database directories as long as they still exist.
 597       origin1_db_dir = tracker->GetFullDBFilePath(kOrigin1, kDB1).DirName();
 598       origin2_db_dir = tracker->GetFullDBFilePath(kOrigin2, kDB2).DirName();
 599
 600       tracker->DatabaseModified(kOrigin1, kDB1);
 601       tracker->DatabaseModified(kOrigin2, kDB2);
 602
 603       // Close all databases.
 604       tracker->DatabaseClosed(kOrigin1, kDB1);
 605       tracker->DatabaseClosed(kOrigin2, kDB2);
 606
 607       tracker->Shutdown();
 608     }
 609
 610     // At this point, the database tracker should be gone. Create a new one.
 611     scoped_refptr<DatabaseTracker> tracker(
 612         new DatabaseTracker(temp_dir.path(), false, NULL, NULL, NULL));
 613
 614     // Get all data for all origins.
 615     std::vector<OriginInfo> origins_info;
 616     EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info));
 617     // kOrigin1 was not session-only, so it survived. kOrigin2 was session-only
 618     // and it got deleted.
 619     EXPECT_EQ(size_t(1), origins_info.size());
 620     EXPECT_EQ(kOrigin1, origins_info[0].GetOriginIdentifier());
 621     EXPECT_TRUE(
 622         base::PathExists(tracker->GetFullDBFilePath(kOrigin1, kDB1)));
 623     EXPECT_EQ(base::FilePath(), tracker->GetFullDBFilePath(kOrigin2, kDB2));
 624
 625     // The origin directory of kOrigin1 remains, but the origin directory of
 626     // kOrigin2 is deleted.
 627     EXPECT_TRUE(base::PathExists(origin1_db_dir));
 628     EXPECT_FALSE(base::PathExists(origin2_db_dir));
 629   }
 630
 631   static void DatabaseTrackerSetForceKeepSessionState() {
 632     int64 database_size = 0;
 633     const std::string kOrigin1 =
 634         webkit_database::GetIdentifierFromOrigin(GURL(kOrigin1Url));
 635     const std::string kOrigin2 =
 636         webkit_database::GetIdentifierFromOrigin(GURL(kOrigin2Url));
 637     const base::string16 kDB1 = ASCIIToUTF16("db1");
 638     const base::string16 kDB2 = ASCIIToUTF16("db2");
 639     const base::string16 kDescription = ASCIIToUTF16("database_description");
 640
 641     // Initialize the tracker database.
 642     base::MessageLoop message_loop;
 643     base::ScopedTempDir temp_dir;
 644     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 645     base::FilePath origin1_db_dir;
 646     base::FilePath origin2_db_dir;
 647     {
 648       scoped_refptr<MockSpecialStoragePolicy> special_storage_policy =
 649           new MockSpecialStoragePolicy;
 650       special_storage_policy->AddSessionOnly(GURL(kOrigin2Url));
 651       scoped_refptr<DatabaseTracker> tracker(
 652           new DatabaseTracker(temp_dir.path(),
 653                               false,
 654                               special_storage_policy.get(),
 655                               NULL,
 656                               base::MessageLoopProxy::current().get()));
 657       tracker->SetForceKeepSessionState();
 658
 659       // Open two new databases.
 660       tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
 661                               &database_size);
 662       EXPECT_EQ(0, database_size);
 663       tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
 664                               &database_size);
 665       EXPECT_EQ(0, database_size);
 666
 667       // Write some data to each file.
 668       base::FilePath db_file;
 669       db_file = tracker->GetFullDBFilePath(kOrigin1, kDB1);
 670       EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
 671       EXPECT_TRUE(EnsureFileOfSize(db_file, 1));
 672
 673       db_file = tracker->GetFullDBFilePath(kOrigin2, kDB2);
 674       EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
 675       EXPECT_TRUE(EnsureFileOfSize(db_file, 2));
 676
 677       // Store the origin database directories as long as they still exist.
 678       origin1_db_dir = tracker->GetFullDBFilePath(kOrigin1, kDB1).DirName();
 679       origin2_db_dir = tracker->GetFullDBFilePath(kOrigin2, kDB2).DirName();
 680
 681       tracker->DatabaseModified(kOrigin1, kDB1);
 682       tracker->DatabaseModified(kOrigin2, kDB2);
 683
 684       // Close all databases.
 685       tracker->DatabaseClosed(kOrigin1, kDB1);
 686       tracker->DatabaseClosed(kOrigin2, kDB2);
 687
 688       tracker->Shutdown();
 689     }
 690
 691     // At this point, the database tracker should be gone. Create a new one.
 692     scoped_refptr<DatabaseTracker> tracker(
 693         new DatabaseTracker(temp_dir.path(), false, NULL, NULL, NULL));
 694
 695     // Get all data for all origins.
 696     std::vector<OriginInfo> origins_info;
 697     EXPECT_TRUE(tracker->GetAllOriginsInfo(&origins_info));
 698     // No origins were deleted.
 699     EXPECT_EQ(size_t(2), origins_info.size());
 700     EXPECT_TRUE(
 701         base::PathExists(tracker->GetFullDBFilePath(kOrigin1, kDB1)));
 702     EXPECT_TRUE(
 703         base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB2)));
 704
 705     EXPECT_TRUE(base::PathExists(origin1_db_dir));
 706     EXPECT_TRUE(base::PathExists(origin2_db_dir));
 707   }
 708
 709   static void EmptyDatabaseNameIsValid() {
 710     const GURL kOrigin(kOrigin1Url);
 711     const std::string kOriginId =
 712         webkit_database::GetIdentifierFromOrigin(kOrigin);
 713     const base::string16 kEmptyName;
 714     const base::string16 kDescription(ASCIIToUTF16("description"));
 715     const base::string16 kChangedDescription(
 716         ASCIIToUTF16("changed_description"));
 717
 718     // Initialize a tracker database, no need to put it on disk.
 719     const bool kUseInMemoryTrackerDatabase = true;
 720     base::ScopedTempDir temp_dir;
 721     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 722     scoped_refptr<DatabaseTracker> tracker(
 723         new DatabaseTracker(temp_dir.path(), kUseInMemoryTrackerDatabase,
 724                             NULL, NULL, NULL));
 725
 726     // Starts off with no databases.
 727     std::vector<OriginInfo> infos;
 728     EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
 729     EXPECT_TRUE(infos.empty());
 730
 731     // Create a db with an empty name.
 732     int64 database_size = -1;
 733     tracker->DatabaseOpened(kOriginId, kEmptyName, kDescription, 0,
 734                             &database_size);
 735     EXPECT_EQ(0, database_size);
 736     tracker->DatabaseModified(kOriginId, kEmptyName);
 737     EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
 738     EXPECT_EQ(1u, infos.size());
 739     EXPECT_EQ(kDescription, infos[0].GetDatabaseDescription(kEmptyName));
 740     EXPECT_FALSE(tracker->GetFullDBFilePath(kOriginId, kEmptyName).empty());
 741     tracker->DatabaseOpened(kOriginId, kEmptyName, kChangedDescription, 0,
 742                             &database_size);
 743     infos.clear();
 744     EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
 745     EXPECT_EQ(1u, infos.size());
 746     EXPECT_EQ(kChangedDescription, infos[0].GetDatabaseDescription(kEmptyName));
 747     tracker->DatabaseClosed(kOriginId, kEmptyName);
 748     tracker->DatabaseClosed(kOriginId, kEmptyName);
 749
 750     // Deleting it should return to the initial state.
 751     EXPECT_EQ(net::OK, tracker->DeleteDatabase(kOriginId, kEmptyName,
 752                                                net::CompletionCallback()));
 753     infos.clear();
 754     EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
 755     EXPECT_TRUE(infos.empty());
 756   }
 757
 758   static void HandleSqliteError() {
 759     const GURL kOrigin(kOrigin1Url);
 760     const std::string kOriginId =
 761         webkit_database::GetIdentifierFromOrigin(kOrigin);
 762     const base::string16 kName(ASCIIToUTF16("name"));
 763     const base::string16 kDescription(ASCIIToUTF16("description"));
 764
 765     // Initialize a tracker database, no need to put it on disk.
 766     const bool kUseInMemoryTrackerDatabase = true;
 767     base::ScopedTempDir temp_dir;
 768     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 769     scoped_refptr<DatabaseTracker> tracker(
 770         new DatabaseTracker(temp_dir.path(), kUseInMemoryTrackerDatabase,
 771                             NULL, NULL, NULL));
 772
 773     // Setup to observe OnScheduledForDelete notifications.
 774     TestObserver observer(false, true);
 775     tracker->AddObserver(&observer);
 776
 777     // Verify does no harm when there is no such database.
 778     tracker->HandleSqliteError(kOriginId, kName, SQLITE_CORRUPT);
 779     EXPECT_FALSE(tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
 780     EXPECT_FALSE(observer.DidReceiveNewNotification());
 781
 782     // --------------------------------------------------------
 783     // Create a record of a database in the tracker db and create
 784     // a spoof_db_file on disk in the expected location.
 785     int64 database_size = 0;
 786     tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
 787                             &database_size);
 788     base::FilePath spoof_db_file = tracker->GetFullDBFilePath(kOriginId, kName);
 789     EXPECT_FALSE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
 790     EXPECT_TRUE(base::CreateDirectory(spoof_db_file.DirName()));
 791     EXPECT_TRUE(EnsureFileOfSize(spoof_db_file, 1));
 792
 793     // Verify does no harm with a non-error is reported.
 794     tracker->HandleSqliteError(kOriginId, kName, SQLITE_OK);
 795     EXPECT_FALSE(tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
 796     EXPECT_FALSE(observer.DidReceiveNewNotification());
 797
 798     // Verify that with a connection open, the db is scheduled for deletion,
 799     // but that the file still exists.
 800     tracker->HandleSqliteError(kOriginId, kName, SQLITE_CORRUPT);
 801     EXPECT_TRUE(tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
 802     EXPECT_TRUE(observer.DidReceiveNewNotification());
 803     EXPECT_TRUE(base::PathExists(spoof_db_file));
 804
 805     // Verify that once closed, the file is deleted and the record in the
 806     // tracker db is removed.
 807     tracker->DatabaseClosed(kOriginId, kName);
 808     EXPECT_FALSE(base::PathExists(spoof_db_file));
 809     EXPECT_TRUE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
 810
 811     // --------------------------------------------------------
 812     // Create another record of a database in the tracker db and create
 813     // a spoof_db_file on disk in the expected location.
 814     tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
 815         &database_size);
 816     base::FilePath spoof_db_file2 = tracker->GetFullDBFilePath(kOriginId,
 817         kName);
 818     EXPECT_FALSE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
 819     EXPECT_NE(spoof_db_file, spoof_db_file2);
 820     EXPECT_TRUE(base::CreateDirectory(spoof_db_file2.DirName()));
 821     EXPECT_TRUE(EnsureFileOfSize(spoof_db_file2, 1));
 822
 823     // Verify that with no connection open, the db is deleted immediately.
 824     tracker->DatabaseClosed(kOriginId, kName);
 825     tracker->HandleSqliteError(kOriginId, kName, SQLITE_CORRUPT);
 826     EXPECT_FALSE(tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
 827     EXPECT_FALSE(observer.DidReceiveNewNotification());
 828     EXPECT_TRUE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
 829     EXPECT_FALSE(base::PathExists(spoof_db_file2));
 830
 831     tracker->RemoveObserver(&observer);
 832   }
 833 };
 834
 835 TEST(DatabaseTrackerTest, DeleteOpenDatabase) {
 836   DatabaseTracker_TestHelper_Test::TestDeleteOpenDatabase(false);
 837 }
 838
 839 TEST(DatabaseTrackerTest, DeleteOpenDatabaseIncognitoMode) {
 840   DatabaseTracker_TestHelper_Test::TestDeleteOpenDatabase(true);
 841 }
 842
 843 TEST(DatabaseTrackerTest, DatabaseTracker) {
 844   DatabaseTracker_TestHelper_Test::TestDatabaseTracker(false);
 845 }
 846
 847 TEST(DatabaseTrackerTest, DatabaseTrackerIncognitoMode) {
 848   DatabaseTracker_TestHelper_Test::TestDatabaseTracker(true);
 849 }
 850
 851 TEST(DatabaseTrackerTest, DatabaseTrackerQuotaIntegration) {
 852   // There is no difference in behavior between incognito and not.
 853   DatabaseTracker_TestHelper_Test::DatabaseTrackerQuotaIntegration();
 854 }
 855
 856 TEST(DatabaseTrackerTest, DatabaseTrackerClearSessionOnlyDatabasesOnExit) {
 857   // Only works for regular mode.
 858   DatabaseTracker_TestHelper_Test::
 859       DatabaseTrackerClearSessionOnlyDatabasesOnExit();
 860 }
 861
 862 TEST(DatabaseTrackerTest, DatabaseTrackerSetForceKeepSessionState) {
 863   // Only works for regular mode.
 864   DatabaseTracker_TestHelper_Test::DatabaseTrackerSetForceKeepSessionState();
 865 }
 866
 867 TEST(DatabaseTrackerTest, EmptyDatabaseNameIsValid) {
 868   DatabaseTracker_TestHelper_Test::EmptyDatabaseNameIsValid();
 869 }
 870
 871 TEST(DatabaseTrackerTest, HandleSqliteError) {
 872   DatabaseTracker_TestHelper_Test::HandleSqliteError();
 873 }
 874
 875 }  // namespace content