Collapse fileapi, webkit_blob, webkit_database, quota, and webkit_common namespaces into single sto…

content/browser/database_tracker_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/file_util.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "content/public/test/mock_special_storage_policy.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/sqlite/sqlite3.h"
 #include "webkit/browser/database/database_tracker.h"
 #include "webkit/browser/quota/quota_manager_proxy.h"
 #include "webkit/common/database/database_identifier.h"
 
 using base::ASCIIToUTF16;
-using webkit_database::DatabaseConnections;
-using webkit_database::DatabaseTracker;
-using webkit_database::OriginInfo;
+using storage::DatabaseConnections;
+using storage::DatabaseTracker;
+using storage::OriginInfo;
 
 namespace {
 
 const char kOrigin1Url[] = "http://origin1";
 const char kOrigin2Url[] = "http://protected_origin2";
 
-class TestObserver : public webkit_database::DatabaseTracker::Observer {
+class TestObserver : public storage::DatabaseTracker::Observer {
  public:
   TestObserver()
       : new_notification_received_(false),
         observe_size_changes_(true),
         observe_scheduled_deletions_(true) {
   }
   TestObserver(bool observe_size_changes, bool observe_scheduled_deletions)
       : new_notification_received_(false),
         observe_size_changes_(observe_size_changes),
         observe_scheduled_deletions_(observe_scheduled_deletions) {
@@ skipping 45 matching lines @@
                                int64 expected_database_size) {
   EXPECT_TRUE(observer->DidReceiveNewNotification());
   EXPECT_EQ(expected_origin_identifier,
             observer->GetNotificationOriginIdentifier());
   EXPECT_EQ(expected_database_name,
             observer->GetNotificationDatabaseName());
   EXPECT_EQ(expected_database_size,
             observer->GetNotificationDatabaseSize());
 }
 
-class TestQuotaManagerProxy : public quota::QuotaManagerProxy {
+class TestQuotaManagerProxy : public storage::QuotaManagerProxy {
  public:
   TestQuotaManagerProxy()
       : QuotaManagerProxy(NULL, NULL),
         registered_client_(NULL) {
   }
 
-  virtual void RegisterClient(quota::QuotaClient* client) OVERRIDE {
+  virtual void RegisterClient(storage::QuotaClient* client) OVERRIDE {
     EXPECT_FALSE(registered_client_);
     registered_client_ = client;
   }
 
-  virtual void NotifyStorageAccessed(quota::QuotaClient::ID client_id,
+  virtual void NotifyStorageAccessed(storage::QuotaClient::ID client_id,
                                      const GURL& origin,
-                                     quota::StorageType type) OVERRIDE {
-    EXPECT_EQ(quota::QuotaClient::kDatabase, client_id);
-    EXPECT_EQ(quota::kStorageTypeTemporary, type);
+                                     storage::StorageType type) OVERRIDE {
+    EXPECT_EQ(storage::QuotaClient::kDatabase, client_id);
+    EXPECT_EQ(storage::kStorageTypeTemporary, type);
     accesses_[origin] += 1;
   }
 
-  virtual void NotifyStorageModified(quota::QuotaClient::ID client_id,
+  virtual void NotifyStorageModified(storage::QuotaClient::ID client_id,
                                      const GURL& origin,
-                                     quota::StorageType type,
+                                     storage::StorageType type,
                                      int64 delta) OVERRIDE {
-    EXPECT_EQ(quota::QuotaClient::kDatabase, client_id);
-    EXPECT_EQ(quota::kStorageTypeTemporary, type);
+    EXPECT_EQ(storage::QuotaClient::kDatabase, client_id);
+    EXPECT_EQ(storage::kStorageTypeTemporary, type);
     modifications_[origin].first += 1;
     modifications_[origin].second += delta;
   }
 
   // Not needed for our tests.
   virtual void NotifyOriginInUse(const GURL& origin) OVERRIDE {}
   virtual void NotifyOriginNoLongerInUse(const GURL& origin) OVERRIDE {}
-  virtual void SetUsageCacheEnabled(quota::QuotaClient::ID client_id,
+  virtual void SetUsageCacheEnabled(storage::QuotaClient::ID client_id,
                                     const GURL& origin,
-                                    quota::StorageType type,
+                                    storage::StorageType type,
                                     bool enabled) OVERRIDE {}
   virtual void GetUsageAndQuota(
       base::SequencedTaskRunner* original_task_runner,
       const GURL& origin,
-      quota::StorageType type,
+      storage::StorageType type,
       const GetUsageAndQuotaCallback& callback) OVERRIDE {}
 
   void SimulateQuotaManagerDestroyed() {
     if (registered_client_) {
       registered_client_->OnQuotaManagerDestroyed();
       registered_client_ = NULL;
     }
   }
 
   bool WasAccessNotified(const GURL& origin) {
     return accesses_[origin] != 0;
   }
 
   bool WasModificationNotified(const GURL& origin, int64 amount) {
     return modifications_[origin].first != 0 &&
            modifications_[origin].second == amount;
   }
 
   void reset() {
     accesses_.clear();
     modifications_.clear();
   }
 
-  quota::QuotaClient* registered_client_;
+  storage::QuotaClient* registered_client_;
 
   // Map from origin to count of access notifications.
   std::map<GURL, int> accesses_;
 
   // Map from origin to <count, sum of deltas>
   std::map<GURL, std::pair<int, int64> > modifications_;
 
  protected:
   virtual ~TestQuotaManagerProxy() {
     EXPECT_FALSE(registered_client_);
@@ skipping 30 matching lines @@
     scoped_refptr<DatabaseTracker> tracker(
         new DatabaseTracker(temp_dir.path(),
                             incognito_mode,
                             special_storage_policy.get(),
                             NULL,
                             NULL));
 
     // Create and open three databases.
     int64 database_size = 0;
     const std::string kOrigin1 =
-        webkit_database::GetIdentifierFromOrigin(GURL(kOrigin1Url));
+        storage::GetIdentifierFromOrigin(GURL(kOrigin1Url));
     const std::string kOrigin2 =
-        webkit_database::GetIdentifierFromOrigin(GURL(kOrigin2Url));
+        storage::GetIdentifierFromOrigin(GURL(kOrigin2Url));
     const base::string16 kDB1 = ASCIIToUTF16("db1");
     const base::string16 kDB2 = ASCIIToUTF16("db2");
     const base::string16 kDB3 = ASCIIToUTF16("db3");
     const base::string16 kDescription = ASCIIToUTF16("database_description");
 
     tracker->DatabaseOpened(kOrigin1, kDB1, kDescription, 0,
                             &database_size);
     tracker->DatabaseOpened(kOrigin2, kDB2, kDescription, 0,
                             &database_size);
     tracker->DatabaseOpened(kOrigin2, kDB3, kDescription, 0,
@@ skipping 91 matching lines @@
 
     // Add two observers.
     TestObserver observer1;
     TestObserver observer2;
     tracker->AddObserver(&observer1);
     tracker->AddObserver(&observer2);
 
     // Open three new databases.
     int64 database_size = 0;
     const std::string kOrigin1 =
-        webkit_database::GetIdentifierFromOrigin(GURL(kOrigin1Url));
+        storage::GetIdentifierFromOrigin(GURL(kOrigin1Url));
     const std::string kOrigin2 =
-        webkit_database::GetIdentifierFromOrigin(GURL(kOrigin2Url));
+        storage::GetIdentifierFromOrigin(GURL(kOrigin2Url));
     const base::string16 kDB1 = ASCIIToUTF16("db1");
     const base::string16 kDB2 = ASCIIToUTF16("db2");
     const base::string16 kDB3 = ASCIIToUTF16("db3");
     const base::string16 kDescription = ASCIIToUTF16("database_description");
 
     // Get the info for kOrigin1 and kOrigin2
     DatabaseTracker::CachedOriginInfo* origin1_info =
         tracker->GetCachedOriginInfo(kOrigin1);
     DatabaseTracker::CachedOriginInfo* origin2_info =
         tracker->GetCachedOriginInfo(kOrigin1);
@@ skipping 104 matching lines @@
     EXPECT_EQ(size_t(1), origins_info.size());
     EXPECT_EQ(kOrigin2, origins_info[0].GetOriginIdentifier());
 
     origin1_info = tracker->GetCachedOriginInfo(kOrigin1);
     EXPECT_TRUE(origin1_info);
     EXPECT_EQ(0, origin1_info->TotalSize());
   }
 
   static void DatabaseTrackerQuotaIntegration() {
     const GURL kOrigin(kOrigin1Url);
-    const std::string kOriginId =
-        webkit_database::GetIdentifierFromOrigin(kOrigin);
+    const std::string kOriginId = storage::GetIdentifierFromOrigin(kOrigin);
     const base::string16 kName = ASCIIToUTF16("name");
     const base::string16 kDescription = ASCIIToUTF16("description");
 
     base::ScopedTempDir temp_dir;
     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
     // Initialize the tracker with a QuotaManagerProxy
     scoped_refptr<TestQuotaManagerProxy> test_quota_proxy(
         new TestQuotaManagerProxy);
     scoped_refptr<DatabaseTracker> tracker(
@@ skipping 77 matching lines @@
     EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
 
     // Cleanup.
     crashed_renderer_connections.RemoveAllConnections();
     test_quota_proxy->SimulateQuotaManagerDestroyed();
   }
 
   static void DatabaseTrackerClearSessionOnlyDatabasesOnExit() {
     int64 database_size = 0;
     const std::string kOrigin1 =
-        webkit_database::GetIdentifierFromOrigin(GURL(kOrigin1Url));
+        storage::GetIdentifierFromOrigin(GURL(kOrigin1Url));
     const std::string kOrigin2 =
-        webkit_database::GetIdentifierFromOrigin(GURL(kOrigin2Url));
+        storage::GetIdentifierFromOrigin(GURL(kOrigin2Url));
     const base::string16 kDB1 = ASCIIToUTF16("db1");
     const base::string16 kDB2 = ASCIIToUTF16("db2");
     const base::string16 kDescription = ASCIIToUTF16("database_description");
 
     // Initialize the tracker database.
     base::MessageLoop message_loop;
     base::ScopedTempDir temp_dir;
     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
     base::FilePath origin1_db_dir;
     base::FilePath origin2_db_dir;
@@ skipping 57 matching lines @@
 
     // The origin directory of kOrigin1 remains, but the origin directory of
     // kOrigin2 is deleted.
     EXPECT_TRUE(base::PathExists(origin1_db_dir));
     EXPECT_FALSE(base::PathExists(origin2_db_dir));
   }
 
   static void DatabaseTrackerSetForceKeepSessionState() {
     int64 database_size = 0;
     const std::string kOrigin1 =
-        webkit_database::GetIdentifierFromOrigin(GURL(kOrigin1Url));
+        storage::GetIdentifierFromOrigin(GURL(kOrigin1Url));
     const std::string kOrigin2 =
-        webkit_database::GetIdentifierFromOrigin(GURL(kOrigin2Url));
+        storage::GetIdentifierFromOrigin(GURL(kOrigin2Url));
     const base::string16 kDB1 = ASCIIToUTF16("db1");
     const base::string16 kDB2 = ASCIIToUTF16("db2");
     const base::string16 kDescription = ASCIIToUTF16("database_description");
 
     // Initialize the tracker database.
     base::MessageLoop message_loop;
     base::ScopedTempDir temp_dir;
     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
     base::FilePath origin1_db_dir;
     base::FilePath origin2_db_dir;
@@ skipping 54 matching lines @@
         base::PathExists(tracker->GetFullDBFilePath(kOrigin1, kDB1)));
     EXPECT_TRUE(
         base::PathExists(tracker->GetFullDBFilePath(kOrigin2, kDB2)));
 
     EXPECT_TRUE(base::PathExists(origin1_db_dir));
     EXPECT_TRUE(base::PathExists(origin2_db_dir));
   }
 
   static void EmptyDatabaseNameIsValid() {
     const GURL kOrigin(kOrigin1Url);
-    const std::string kOriginId =
-        webkit_database::GetIdentifierFromOrigin(kOrigin);
+    const std::string kOriginId = storage::GetIdentifierFromOrigin(kOrigin);
     const base::string16 kEmptyName;
     const base::string16 kDescription(ASCIIToUTF16("description"));
     const base::string16 kChangedDescription(
         ASCIIToUTF16("changed_description"));
 
     // Initialize a tracker database, no need to put it on disk.
     const bool kUseInMemoryTrackerDatabase = true;
     base::ScopedTempDir temp_dir;
     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
     scoped_refptr<DatabaseTracker> tracker(
@@ skipping 27 matching lines @@
     // Deleting it should return to the initial state.
     EXPECT_EQ(net::OK, tracker->DeleteDatabase(kOriginId, kEmptyName,
                                                net::CompletionCallback()));
     infos.clear();
     EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
     EXPECT_TRUE(infos.empty());
   }
 
   static void HandleSqliteError() {
     const GURL kOrigin(kOrigin1Url);
-    const std::string kOriginId =
-        webkit_database::GetIdentifierFromOrigin(kOrigin);
+    const std::string kOriginId = storage::GetIdentifierFromOrigin(kOrigin);
     const base::string16 kName(ASCIIToUTF16("name"));
     const base::string16 kDescription(ASCIIToUTF16("description"));
 
     // Initialize a tracker database, no need to put it on disk.
     const bool kUseInMemoryTrackerDatabase = true;
     base::ScopedTempDir temp_dir;
     ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
     scoped_refptr<DatabaseTracker> tracker(
         new DatabaseTracker(temp_dir.path(), kUseInMemoryTrackerDatabase,
                             NULL, NULL, NULL));
@@ skipping 94 matching lines @@
 
 TEST(DatabaseTrackerTest, EmptyDatabaseNameIsValid) {
   DatabaseTracker_TestHelper_Test::EmptyDatabaseNameIsValid();
 }
 
 TEST(DatabaseTrackerTest, HandleSqliteError) {
   DatabaseTracker_TestHelper_Test::HandleSqliteError();
 }
 
 }  // namespace content