Switch to standard integer types in content/browser/.

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 <stddef.h>
+#include <stdint.h>
+
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "content/public/test/mock_special_storage_policy.h"
@@ skipping 24 matching lines @@
   }
   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) {
   }
 
   ~TestObserver() override {}
   void OnDatabaseSizeChanged(const std::string& origin_identifier,
                              const base::string16& database_name,
-                             int64 database_size) override {
+                             int64_t database_size) override {
     if (!observe_size_changes_)
       return;
     new_notification_received_ = true;
     origin_identifier_ = origin_identifier;
     database_name_ = database_name;
     database_size_ = database_size;
   }
   void OnDatabaseScheduledForDeletion(
       const std::string& origin_identifier,
       const base::string16& database_name) override {
     if (!observe_scheduled_deletions_)
       return;
     new_notification_received_ = true;
     origin_identifier_ = origin_identifier;
     database_name_ = database_name;
   }
   bool DidReceiveNewNotification() {
     bool temp_new_notification_received = new_notification_received_;
     new_notification_received_ = false;
     return temp_new_notification_received;
   }
   std::string GetNotificationOriginIdentifier() {
     return origin_identifier_;
   }
   base::string16 GetNotificationDatabaseName() { return database_name_; }
-  int64 GetNotificationDatabaseSize() { return database_size_; }
+  int64_t GetNotificationDatabaseSize() { return database_size_; }
 
  private:
   bool new_notification_received_;
   bool observe_size_changes_;
   bool observe_scheduled_deletions_;
   std::string origin_identifier_;
   base::string16 database_name_;
-  int64 database_size_;
+  int64_t database_size_;
 };
 
 void CheckNotificationReceived(TestObserver* observer,
                                const std::string& expected_origin_identifier,
                                const base::string16& expected_database_name,
-                               int64 expected_database_size) {
+                               int64_t 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 storage::QuotaManagerProxy {
@@ skipping 12 matching lines @@
                              const GURL& origin,
                              storage::StorageType type) override {
     EXPECT_EQ(storage::QuotaClient::kDatabase, client_id);
     EXPECT_EQ(storage::kStorageTypeTemporary, type);
     accesses_[origin] += 1;
   }
 
   void NotifyStorageModified(storage::QuotaClient::ID client_id,
                              const GURL& origin,
                              storage::StorageType type,
-                             int64 delta) override {
+                             int64_t delta) override {
     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.
   void NotifyOriginInUse(const GURL& origin) override {}
   void NotifyOriginNoLongerInUse(const GURL& origin) override {}
   void SetUsageCacheEnabled(storage::QuotaClient::ID client_id,
                             const GURL& origin,
                             storage::StorageType type,
                             bool enabled) override {}
   void GetUsageAndQuota(base::SequencedTaskRunner* original_task_runner,
                         const GURL& origin,
                         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) {
+  bool WasModificationNotified(const GURL& origin, int64_t amount) {
     return modifications_[origin].first != 0 &&
            modifications_[origin].second == amount;
   }
 
   void reset() {
     accesses_.clear();
     modifications_.clear();
   }
 
   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_;
+  std::map<GURL, std::pair<int, int64_t>> modifications_;
 
  protected:
   ~TestQuotaManagerProxy() override { EXPECT_FALSE(registered_client_); }
 };
 
-
-bool EnsureFileOfSize(const base::FilePath& file_path, int64 length) {
+bool EnsureFileOfSize(const base::FilePath& file_path, int64_t length) {
   base::File file(file_path,
                   base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_WRITE);
   if (!file.IsValid())
     return false;
   return file.SetLength(length);
 }
 
 }  // namespace
 
 namespace content {
@@ skipping 13 matching lines @@
         new MockSpecialStoragePolicy;
     special_storage_policy->AddProtected(GURL(kOrigin2Url));
     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;
+    int64_t database_size = 0;
     const std::string kOrigin1 =
         storage::GetIdentifierFromOrigin(GURL(kOrigin1Url));
     const std::string kOrigin2 =
         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,
@@ skipping 93 matching lines @@
                             NULL,
                             NULL));
 
     // Add two observers.
     TestObserver observer1;
     TestObserver observer2;
     tracker->AddObserver(&observer1);
     tracker->AddObserver(&observer2);
 
     // Open three new databases.
-    int64 database_size = 0;
+    int64_t database_size = 0;
     const std::string kOrigin1 =
         storage::GetIdentifierFromOrigin(GURL(kOrigin1Url));
     const std::string kOrigin2 =
         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
@@ skipping 129 matching lines @@
         new DatabaseTracker(temp_dir.path(),
                             false /* incognito */,
                             NULL,
                             test_quota_proxy.get(),
                             NULL));
     EXPECT_TRUE(test_quota_proxy->registered_client_);
 
     // Create a database and modify it a couple of times, close it,
     // then delete it. Observe the tracker notifies accordingly.
 
-    int64 database_size = 0;
+    int64_t database_size = 0;
     tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
                             &database_size);
     EXPECT_TRUE(test_quota_proxy->WasAccessNotified(kOrigin));
     test_quota_proxy->reset();
 
     base::FilePath db_file(tracker->GetFullDBFilePath(kOriginId, kName));
     EXPECT_TRUE(base::CreateDirectory(db_file.DirName()));
     EXPECT_TRUE(EnsureFileOfSize(db_file, 10));
     tracker->DatabaseModified(kOriginId, kName);
     EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 10));
@@ skipping 54 matching lines @@
     EXPECT_FALSE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
     tracker->CloseDatabases(crashed_renderer_connections);
     EXPECT_TRUE(test_quota_proxy->WasModificationNotified(kOrigin, 100));
 
     // Cleanup.
     crashed_renderer_connections.RemoveAllConnections();
     test_quota_proxy->SimulateQuotaManagerDestroyed();
   }
 
   static void DatabaseTrackerClearSessionOnlyDatabasesOnExit() {
-    int64 database_size = 0;
+    int64_t database_size = 0;
     const std::string kOrigin1 =
         storage::GetIdentifierFromOrigin(GURL(kOrigin1Url));
     const std::string kOrigin2 =
         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;
@@ skipping 56 matching lines @@
         base::PathExists(tracker->GetFullDBFilePath(kOrigin1, kDB1)));
     EXPECT_EQ(base::FilePath(), tracker->GetFullDBFilePath(kOrigin2, kDB2));
 
     // 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;
+    int64_t database_size = 0;
     const std::string kOrigin1 =
         storage::GetIdentifierFromOrigin(GURL(kOrigin1Url));
     const std::string kOrigin2 =
         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;
@@ skipping 75 matching lines @@
     scoped_refptr<DatabaseTracker> tracker(
         new DatabaseTracker(temp_dir.path(), kUseInMemoryTrackerDatabase,
                             NULL, NULL, NULL));
 
     // Starts off with no databases.
     std::vector<OriginInfo> infos;
     EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
     EXPECT_TRUE(infos.empty());
 
     // Create a db with an empty name.
-    int64 database_size = -1;
+    int64_t database_size = -1;
     tracker->DatabaseOpened(kOriginId, kEmptyName, kDescription, 0,
                             &database_size);
     EXPECT_EQ(0, database_size);
     tracker->DatabaseModified(kOriginId, kEmptyName);
     EXPECT_TRUE(tracker->GetAllOriginsInfo(&infos));
     EXPECT_EQ(1u, infos.size());
     EXPECT_EQ(kDescription, infos[0].GetDatabaseDescription(kEmptyName));
     EXPECT_FALSE(tracker->GetFullDBFilePath(kOriginId, kEmptyName).empty());
     tracker->DatabaseOpened(kOriginId, kEmptyName, kChangedDescription, 0,
                             &database_size);
@@ skipping 31 matching lines @@
     tracker->AddObserver(&observer);
 
     // Verify does no harm when there is no such database.
     tracker->HandleSqliteError(kOriginId, kName, SQLITE_CORRUPT);
     EXPECT_FALSE(tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
     EXPECT_FALSE(observer.DidReceiveNewNotification());
 
     // --------------------------------------------------------
     // Create a record of a database in the tracker db and create
     // a spoof_db_file on disk in the expected location.
-    int64 database_size = 0;
+    int64_t database_size = 0;
     tracker->DatabaseOpened(kOriginId, kName, kDescription, 0,
                             &database_size);
     base::FilePath spoof_db_file = tracker->GetFullDBFilePath(kOriginId, kName);
     EXPECT_FALSE(tracker->GetFullDBFilePath(kOriginId, kName).empty());
     EXPECT_TRUE(base::CreateDirectory(spoof_db_file.DirName()));
     EXPECT_TRUE(EnsureFileOfSize(spoof_db_file, 1));
 
     // Verify does no harm with a non-error is reported.
     tracker->HandleSqliteError(kOriginId, kName, SQLITE_OK);
     EXPECT_FALSE(tracker->IsDatabaseScheduledForDeletion(kOriginId, kName));
@@ skipping 70 matching lines @@
 
 TEST(DatabaseTrackerTest, EmptyDatabaseNameIsValid) {
   DatabaseTracker_TestHelper_Test::EmptyDatabaseNameIsValid();
 }
 
 TEST(DatabaseTrackerTest, HandleSqliteError) {
   DatabaseTracker_TestHelper_Test::HandleSqliteError();
 }
 
 }  // namespace content