Switch to standard integer types in content/browser/.

content/browser/quota/quota_manager_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 <algorithm>
 #include <set>
 #include <sstream>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/sys_info.h"
 #include "base/test/histogram_tester.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "content/public/test/mock_special_storage_policy.h"
 #include "content/public/test/mock_storage_client.h"
@@ skipping 24 matching lines @@
 
 namespace {
 
 // For shorter names.
 const StorageType kTemp = kStorageTypeTemporary;
 const StorageType kPerm = kStorageTypePersistent;
 const StorageType kSync = kStorageTypeSyncable;
 
 const int kAllClients = QuotaClient::kAllClientsMask;
 
-const int64 kAvailableSpaceForApp = 13377331U;
+const int64_t kAvailableSpaceForApp = 13377331U;
 
-const int64 kMinimumPreserveForSystem = QuotaManager::kMinimumPreserveForSystem;
+const int64_t kMinimumPreserveForSystem =
+    QuotaManager::kMinimumPreserveForSystem;
 const int kPerHostTemporaryPortion = QuotaManager::kPerHostTemporaryPortion;
 
 const GURL kTestEvictionOrigin = GURL("http://test.eviction.policy/result");
 
 // Returns a deterministic value for the amount of available disk space.
-int64 GetAvailableDiskSpaceForTest(const base::FilePath&) {
+int64_t GetAvailableDiskSpaceForTest(const base::FilePath&) {
   return kAvailableSpaceForApp + kMinimumPreserveForSystem;
 }
 
 class TestEvictionPolicy : public storage::QuotaEvictionPolicy {
  public:
   TestEvictionPolicy() {}
   ~TestEvictionPolicy() override {}
 
   // Overridden from storage::QuotaEvictionPolicy:
   void GetEvictionOrigin(const scoped_refptr<storage::SpecialStoragePolicy>&
                              special_storage_policy,
                          const std::set<GURL>& exceptions,
-                         const std::map<GURL, int64>& usage_map,
-                         int64 global_quota,
+                         const std::map<GURL, int64_t>& usage_map,
+                         int64_t global_quota,
                          const storage::GetOriginCallback& callback) override {
     callback.Run(kTestEvictionOrigin);
   }
 };
 
 }  // namespace
 
 class QuotaManagerTest : public testing::Test {
  protected:
   typedef QuotaManager::QuotaTableEntry QuotaTableEntry;
@@ skipping 71 matching lines @@
   }
 
   void GetTemporaryGlobalQuota() {
     quota_status_ = kQuotaStatusUnknown;
     quota_ = -1;
     quota_manager_->GetTemporaryGlobalQuota(
         base::Bind(&QuotaManagerTest::DidGetQuota,
                    weak_factory_.GetWeakPtr()));
   }
 
-  void SetTemporaryGlobalQuota(int64 new_quota) {
+  void SetTemporaryGlobalQuota(int64_t new_quota) {
     quota_status_ = kQuotaStatusUnknown;
     quota_ = -1;
     quota_manager_->SetTemporaryGlobalOverrideQuota(
         new_quota,
         base::Bind(&QuotaManagerTest::DidGetQuota,
                    weak_factory_.GetWeakPtr()));
   }
 
   void GetPersistentHostQuota(const std::string& host) {
     quota_status_ = kQuotaStatusUnknown;
     quota_ = -1;
     quota_manager_->GetPersistentHostQuota(
         host,
         base::Bind(&QuotaManagerTest::DidGetHostQuota,
                    weak_factory_.GetWeakPtr()));
   }
 
-  void SetPersistentHostQuota(const std::string& host, int64 new_quota) {
+  void SetPersistentHostQuota(const std::string& host, int64_t new_quota) {
     quota_status_ = kQuotaStatusUnknown;
     quota_ = -1;
     quota_manager_->SetPersistentHostQuota(
         host, new_quota,
         base::Bind(&QuotaManagerTest::DidGetHostQuota,
                    weak_factory_.GetWeakPtr()));
   }
 
   void GetGlobalUsage(StorageType type) {
     usage_ = -1;
@@ skipping 140 matching lines @@
     origin_info_entries_.clear();
     quota_manager_->DumpOriginInfoTable(
         base::Bind(&QuotaManagerTest::DidDumpOriginInfoTable,
                    weak_factory_.GetWeakPtr()));
   }
 
   void DidGetUsageInfo(const UsageInfoEntries& entries) {
     usage_info_.insert(usage_info_.begin(), entries.begin(), entries.end());
   }
 
-  void DidGetUsageAndQuota(QuotaStatusCode status, int64 usage, int64 quota) {
+  void DidGetUsageAndQuota(QuotaStatusCode status,
+                           int64_t usage,
+                           int64_t quota) {
     quota_status_ = status;
     usage_ = usage;
     quota_ = quota;
   }
 
-  void DidGetQuota(QuotaStatusCode status,
-                   int64 quota) {
+  void DidGetQuota(QuotaStatusCode status, int64_t quota) {
     quota_status_ = status;
     quota_ = quota;
   }
 
-  void DidGetAvailableSpace(QuotaStatusCode status, int64 available_space) {
+  void DidGetAvailableSpace(QuotaStatusCode status, int64_t available_space) {
     quota_status_ = status;
     available_space_ = available_space;
   }
 
-  void DidGetHostQuota(QuotaStatusCode status,
-                       int64 quota) {
+  void DidGetHostQuota(QuotaStatusCode status, int64_t quota) {
     quota_status_ = status;
     quota_ = quota;
   }
 
-  void DidGetGlobalUsage(int64 usage,
-                         int64 unlimited_usage) {
+  void DidGetGlobalUsage(int64_t usage, int64_t unlimited_usage) {
     usage_ = usage;
     unlimited_usage_ = unlimited_usage;
   }
 
-  void DidGetHostUsage(int64 usage) {
-    usage_ = usage;
-  }
+  void DidGetHostUsage(int64_t usage) { usage_ = usage; }
 
   void StatusCallback(QuotaStatusCode status) {
     ++status_callback_count_;
     quota_status_ = status;
   }
 
   void DidGetUsageAndQuotaForEviction(QuotaStatusCode status,
                                       const UsageAndQuota& usage_and_quota) {
     quota_status_ = status;
     limited_usage_ = usage_and_quota.global_limited_usage;
@@ skipping 15 matching lines @@
   }
 
   void DidDumpOriginInfoTable(const OriginInfoTableEntries& entries) {
     origin_info_entries_ = entries;
   }
 
   void GetUsage_WithModifyTestBody(const StorageType type);
 
   void set_additional_callback_count(int c) { additional_callback_count_ = c; }
   int additional_callback_count() const { return additional_callback_count_; }
-  void DidGetUsageAndQuotaAdditional(
-      QuotaStatusCode status, int64 usage, int64 quota) {
+  void DidGetUsageAndQuotaAdditional(QuotaStatusCode status,
+                                     int64_t usage,
+                                     int64_t quota) {
     ++additional_callback_count_;
   }
 
   QuotaManager* quota_manager() const { return quota_manager_.get(); }
   void set_quota_manager(QuotaManager* quota_manager) {
     quota_manager_ = quota_manager;
   }
 
   MockSpecialStoragePolicy* mock_special_storage_policy() const {
     return mock_special_storage_policy_.get();
   }
 
   QuotaStatusCode status() const { return quota_status_; }
   const UsageInfoEntries& usage_info() const { return usage_info_; }
-  int64 usage() const { return usage_; }
-  int64 limited_usage() const { return limited_usage_; }
-  int64 unlimited_usage() const { return unlimited_usage_; }
-  int64 quota() const { return quota_; }
-  int64 available_space() const { return available_space_; }
+  int64_t usage() const { return usage_; }
+  int64_t limited_usage() const { return limited_usage_; }
+  int64_t unlimited_usage() const { return unlimited_usage_; }
+  int64_t quota() const { return quota_; }
+  int64_t available_space() const { return available_space_; }
   const GURL& eviction_origin() const { return eviction_origin_; }
   const std::set<GURL>& modified_origins() const { return modified_origins_; }
   StorageType modified_origins_type() const { return modified_origins_type_; }
   const QuotaTableEntries& quota_entries() const { return quota_entries_; }
   const OriginInfoTableEntries& origin_info_entries() const {
     return origin_info_entries_;
   }
   base::FilePath profile_path() const { return data_dir_.path(); }
   int status_callback_count() const { return status_callback_count_; }
   void reset_status_callback_count() { status_callback_count_ = 0; }
 
  private:
   base::Time IncrementMockTime() {
     ++mock_time_counter_;
     return base::Time::FromDoubleT(mock_time_counter_ * 10.0);
   }
 
   base::MessageLoop message_loop_;
   base::ScopedTempDir data_dir_;
 
   scoped_refptr<QuotaManager> quota_manager_;
   scoped_refptr<MockSpecialStoragePolicy> mock_special_storage_policy_;
 
   QuotaStatusCode quota_status_;
   UsageInfoEntries usage_info_;
-  int64 usage_;
-  int64 limited_usage_;
-  int64 unlimited_usage_;
-  int64 quota_;
-  int64 available_space_;
+  int64_t usage_;
+  int64_t limited_usage_;
+  int64_t unlimited_usage_;
+  int64_t quota_;
+  int64_t available_space_;
   GURL eviction_origin_;
   std::set<GURL> modified_origins_;
   StorageType modified_origins_type_;
   QuotaTableEntries quota_entries_;
   OriginInfoTableEntries origin_info_entries_;
   int status_callback_count_;
 
   int additional_callback_count_;
 
   int mock_time_counter_;
@@ skipping 54 matching lines @@
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(80, usage());
   EXPECT_EQ(0, quota());
 
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10, usage());
   EXPECT_LE(0, quota());
-  int64 quota_returned_for_foo = quota();
+  int64_t quota_returned_for_foo = quota();
 
   GetUsageAndQuotaForWebApps(GURL("http://bar.com/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(0, usage());
   EXPECT_EQ(quota_returned_for_foo, quota());
 }
 
 TEST_F(QuotaManagerTest, GetUsage_NoClient) {
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
@@ skipping 106 matching lines @@
     { "http://unlimited/",            kTemp, 512 },
     { "http://installed/",            kTemp, 1024 },
   };
   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
   mock_special_storage_policy()->GrantQueryDiskSize(GURL("http://installed/"));
   RegisterClient(CreateClient(kData1, arraysize(kData1),
       QuotaClient::kFileSystem));
   RegisterClient(CreateClient(kData2, arraysize(kData2),
       QuotaClient::kDatabase));
 
-  const int64 kTempQuotaBase =
+  const int64_t kTempQuotaBase =
       GetAvailableDiskSpaceForTest(base::FilePath()) / kPerHostTemporaryPortion;
 
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(1 + 128, usage());
 
   GetUsageAndQuotaForWebApps(GURL("http://bar.com/"), kPerm);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
@@ skipping 568 matching lines @@
     { "http://foo.com:1/", kTemp,    20 },
     { "http://foo.com/",   kPerm,   300 },
     { "http://bar.com/",   kTemp,  4000 },
   };
   MockStorageClient* client = CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem);
   RegisterClient(client);
 
   GetGlobalUsage(kTemp);
   base::RunLoop().RunUntilIdle();
-  int64 predelete_global_tmp = usage();
+  int64_t predelete_global_tmp = usage();
 
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
-  int64 predelete_host_tmp = usage();
+  int64_t predelete_host_tmp = usage();
 
   GetHostUsage("foo.com", kPerm);
   base::RunLoop().RunUntilIdle();
-  int64 predelete_host_pers = usage();
+  int64_t predelete_host_pers = usage();
 
   DeleteClientOriginData(client, GURL("http://foo.com/"),
                          kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
 
   GetGlobalUsage(kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(predelete_global_tmp - 1, usage());
 
@@ skipping 38 matching lines @@
   };
   MockStorageClient* client1 = CreateClient(kData1, arraysize(kData1),
       QuotaClient::kFileSystem);
   MockStorageClient* client2 = CreateClient(kData2, arraysize(kData2),
       QuotaClient::kDatabase);
   RegisterClient(client1);
   RegisterClient(client2);
 
   GetGlobalUsage(kTemp);
   base::RunLoop().RunUntilIdle();
-  int64 predelete_global_tmp = usage();
+  int64_t predelete_global_tmp = usage();
 
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
-  int64 predelete_host_tmp = usage();
+  int64_t predelete_host_tmp = usage();
 
   GetHostUsage("foo.com", kPerm);
   base::RunLoop().RunUntilIdle();
-  int64 predelete_host_pers = usage();
+  int64_t predelete_host_pers = usage();
 
   for (size_t i = 0; i < arraysize(kData1); ++i)
     quota_manager()->NotifyStorageAccessed(QuotaClient::kUnknown,
         GURL(kData1[i].origin), kData1[i].type);
   for (size_t i = 0; i < arraysize(kData2); ++i)
     quota_manager()->NotifyStorageAccessed(QuotaClient::kUnknown,
         GURL(kData2[i].origin), kData2[i].type);
   base::RunLoop().RunUntilIdle();
 
   EvictOriginData(GURL("http://foo.com/"), kTemp);
@@ skipping 96 matching lines @@
     { "http://foo.com/",   kPerm,     300 },
     { "http://bar.com/",   kTemp,    4000 },
   };
   static const int kNumberOfTemporaryOrigins = 3;
   MockStorageClient* client = CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem);
   RegisterClient(client);
 
   GetGlobalUsage(kTemp);
   base::RunLoop().RunUntilIdle();
-  int64 predelete_global_tmp = usage();
+  int64_t predelete_global_tmp = usage();
 
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
-  int64 predelete_host_tmp = usage();
+  int64_t predelete_host_tmp = usage();
 
   GetHostUsage("foo.com", kPerm);
   base::RunLoop().RunUntilIdle();
-  int64 predelete_host_pers = usage();
+  int64_t predelete_host_pers = usage();
 
   for (size_t i = 0; i < arraysize(kData); ++i)
     NotifyStorageAccessed(client, GURL(kData[i].origin), kData[i].type);
   base::RunLoop().RunUntilIdle();
 
   client->AddOriginToErrorSet(GURL("http://foo.com/"), kTemp);
 
   for (int i = 0;
        i < QuotaManager::kThresholdOfErrorsToBeBlacklisted + 1;
        ++i) {
@@ skipping 76 matching lines @@
 TEST_F(QuotaManagerTest, DeleteHostDataSimple) {
   static const MockOriginData kData[] = {
     { "http://foo.com/",   kTemp,     1 },
   };
   MockStorageClient* client = CreateClient(kData, arraysize(kData),
       QuotaClient::kFileSystem);
   RegisterClient(client);
 
   GetGlobalUsage(kTemp);
   base::RunLoop().RunUntilIdle();
-  const int64 predelete_global_tmp = usage();
+  const int64_t predelete_global_tmp = usage();
 
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
-  int64 predelete_host_tmp = usage();
+  int64_t predelete_host_tmp = usage();
 
   GetHostUsage("foo.com", kPerm);
   base::RunLoop().RunUntilIdle();
-  int64 predelete_host_pers = usage();
+  int64_t predelete_host_pers = usage();
 
   DeleteHostData(std::string(), kTemp, kAllClients);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
 
   GetGlobalUsage(kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(predelete_global_tmp, usage());
 
   GetHostUsage("foo.com", kTemp);
@@ skipping 37 matching lines @@
   };
   MockStorageClient* client1 = CreateClient(kData1, arraysize(kData1),
       QuotaClient::kFileSystem);
   MockStorageClient* client2 = CreateClient(kData2, arraysize(kData2),
       QuotaClient::kDatabase);
   RegisterClient(client1);
   RegisterClient(client2);
 
   GetGlobalUsage(kTemp);
   base::RunLoop().RunUntilIdle();
-  const int64 predelete_global_tmp = usage();
+  const int64_t predelete_global_tmp = usage();
 
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
-  const int64 predelete_foo_tmp = usage();
+  const int64_t predelete_foo_tmp = usage();
 
   GetHostUsage("bar.com", kTemp);
   base::RunLoop().RunUntilIdle();
-  const int64 predelete_bar_tmp = usage();
+  const int64_t predelete_bar_tmp = usage();
 
   GetHostUsage("foo.com", kPerm);
   base::RunLoop().RunUntilIdle();
-  const int64 predelete_foo_pers = usage();
+  const int64_t predelete_foo_pers = usage();
 
   GetHostUsage("bar.com", kPerm);
   base::RunLoop().RunUntilIdle();
-  const int64 predelete_bar_pers = usage();
+  const int64_t predelete_bar_pers = usage();
 
   reset_status_callback_count();
   DeleteHostData("foo.com", kTemp, kAllClients);
   DeleteHostData("bar.com", kTemp, kAllClients);
   DeleteHostData("foo.com", kTemp, kAllClients);
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(3, status_callback_count());
 
   DumpOriginInfoTable();
@@ skipping 51 matching lines @@
   };
   MockStorageClient* client1 = CreateClient(kData1, arraysize(kData1),
       QuotaClient::kFileSystem);
   MockStorageClient* client2 = CreateClient(kData2, arraysize(kData2),
       QuotaClient::kDatabase);
   RegisterClient(client1);
   RegisterClient(client2);
 
   GetGlobalUsage(kTemp);
   base::RunLoop().RunUntilIdle();
-  const int64 predelete_global_tmp = usage();
+  const int64_t predelete_global_tmp = usage();
 
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
-  const int64 predelete_foo_tmp = usage();
+  const int64_t predelete_foo_tmp = usage();
 
   GetHostUsage("bar.com", kTemp);
   base::RunLoop().RunUntilIdle();
-  const int64 predelete_bar_tmp = usage();
+  const int64_t predelete_bar_tmp = usage();
 
   GetHostUsage("foo.com", kPerm);
   base::RunLoop().RunUntilIdle();
-  const int64 predelete_foo_pers = usage();
+  const int64_t predelete_foo_pers = usage();
 
   GetHostUsage("bar.com", kPerm);
   base::RunLoop().RunUntilIdle();
-  const int64 predelete_bar_pers = usage();
+  const int64_t predelete_bar_pers = usage();
 
   for (size_t i = 0; i < arraysize(kData1); ++i)
     quota_manager()->NotifyStorageAccessed(QuotaClient::kUnknown,
         GURL(kData1[i].origin), kData1[i].type);
   for (size_t i = 0; i < arraysize(kData2); ++i)
     quota_manager()->NotifyStorageAccessed(QuotaClient::kUnknown,
         GURL(kData2[i].origin), kData2[i].type);
   base::RunLoop().RunUntilIdle();
 
   reset_status_callback_count();
@@ skipping 331 matching lines @@
       QuotaClient::kDatabase);
   MockStorageClient* client4 = CreateClient(kData4, arraysize(kData4),
       QuotaClient::kIndexedDatabase);
   RegisterClient(client1);
   RegisterClient(client2);
   RegisterClient(client3);
   RegisterClient(client4);
 
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
-  const int64 predelete_foo_tmp = usage();
+  const int64_t predelete_foo_tmp = usage();
 
   DeleteOriginData(GURL("http://foo.com/"), kTemp, QuotaClient::kFileSystem);
   base::RunLoop().RunUntilIdle();
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(predelete_foo_tmp - 1, usage());
 
   DeleteOriginData(GURL("http://foo.com/"), kTemp, QuotaClient::kAppcache);
   base::RunLoop().RunUntilIdle();
   GetHostUsage("foo.com", kTemp);
@@ skipping 35 matching lines @@
       QuotaClient::kDatabase);
   MockStorageClient* client4 = CreateClient(kData4, arraysize(kData4),
       QuotaClient::kIndexedDatabase);
   RegisterClient(client1);
   RegisterClient(client2);
   RegisterClient(client3);
   RegisterClient(client4);
 
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
-  const int64 predelete_foo_tmp = usage();
+  const int64_t predelete_foo_tmp = usage();
 
   DeleteHostData("foo.com", kTemp, QuotaClient::kFileSystem);
   base::RunLoop().RunUntilIdle();
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(predelete_foo_tmp - 1, usage());
 
   DeleteHostData("foo.com", kTemp, QuotaClient::kAppcache);
   base::RunLoop().RunUntilIdle();
   GetHostUsage("foo.com", kTemp);
@@ skipping 34 matching lines @@
       QuotaClient::kDatabase);
   MockStorageClient* client4 = CreateClient(kData4, arraysize(kData4),
       QuotaClient::kIndexedDatabase);
   RegisterClient(client1);
   RegisterClient(client2);
   RegisterClient(client3);
   RegisterClient(client4);
 
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
-  const int64 predelete_foo_tmp = usage();
+  const int64_t predelete_foo_tmp = usage();
 
   DeleteOriginData(GURL("http://foo.com/"), kTemp,
       QuotaClient::kFileSystem | QuotaClient::kDatabase);
   base::RunLoop().RunUntilIdle();
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(predelete_foo_tmp - 4 - 1, usage());
 
   DeleteOriginData(GURL("http://foo.com/"), kTemp,
       QuotaClient::kAppcache | QuotaClient::kIndexedDatabase);
@@ skipping 24 matching lines @@
       QuotaClient::kDatabase);
   MockStorageClient* client4 = CreateClient(kData4, arraysize(kData4),
       QuotaClient::kIndexedDatabase);
   RegisterClient(client1);
   RegisterClient(client2);
   RegisterClient(client3);
   RegisterClient(client4);
 
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
-  const int64 predelete_foo_tmp = usage();
+  const int64_t predelete_foo_tmp = usage();
 
   DeleteHostData("foo.com", kTemp,
       QuotaClient::kFileSystem | QuotaClient::kAppcache);
   base::RunLoop().RunUntilIdle();
   GetHostUsage("foo.com", kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(predelete_foo_tmp - 2 - 1, usage());
 
   DeleteHostData("foo.com", kTemp,
       QuotaClient::kDatabase | QuotaClient::kIndexedDatabase);
@@ skipping 17 matching lines @@
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(80, usage());
   EXPECT_EQ(0, quota());
 
   SetTemporaryGlobalQuota(100);
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10, usage());
-  EXPECT_LE(std::min(static_cast<int64>(100 / kPerHostTemporaryPortion),
-                     QuotaManager::kIncognitoDefaultQuotaLimit), quota());
+  EXPECT_LE(std::min(static_cast<int64_t>(100 / kPerHostTemporaryPortion),
+                     QuotaManager::kIncognitoDefaultQuotaLimit),
+            quota());
 
   mock_special_storage_policy()->AddUnlimited(GURL("http://foo.com/"));
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(80, usage());
   EXPECT_EQ(QuotaManager::kIncognitoDefaultQuotaLimit, quota());
 
   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kQuotaStatusOk, status());
   EXPECT_EQ(10, usage());
   EXPECT_EQ(QuotaManager::kIncognitoDefaultQuotaLimit, quota());
 }
 
 TEST_F(QuotaManagerTest, GetVolumeInfo) {
   // We aren't actually testing that it's correct, just that it's sane.
   base::FilePath tmp_dir;
   ASSERT_TRUE(base::GetTempDir(&tmp_dir));
   uint64_t available_space = 0;
   uint64_t total_size = 0;
   EXPECT_TRUE(GetVolumeInfo(tmp_dir, &available_space, &total_size));
   EXPECT_GT(available_space, 0u) << tmp_dir.value();
   EXPECT_GT(total_size, 0u) << tmp_dir.value();
 }
 
 }  // namespace content