Switch to standard integer types in content/browser/.

content/browser/quota/usage_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 <stdint.h>
+
 #include "base/bind.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/public/test/mock_special_storage_policy.h"
 #include "net/base/net_util.h"
 #include "storage/browser/quota/usage_tracker.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using storage::kQuotaStatusOk;
 using storage::kStorageTypeTemporary;
 using storage::QuotaClient;
 using storage::QuotaClientList;
 using storage::SpecialStoragePolicy;
 using storage::StorageType;
 using storage::UsageTracker;
 
 namespace content {
 
 namespace {
 
 void DidGetGlobalUsage(bool* done,
-                       int64* usage_out,
-                       int64* unlimited_usage_out,
-                       int64 usage,
-                       int64 unlimited_usage) {
+                       int64_t* usage_out,
+                       int64_t* unlimited_usage_out,
+                       int64_t usage,
+                       int64_t unlimited_usage) {
   EXPECT_FALSE(*done);
   *done = true;
   *usage_out = usage;
   *unlimited_usage_out = unlimited_usage;
 }
 
-void DidGetUsage(bool* done,
-                 int64* usage_out,
-                 int64 usage) {
+void DidGetUsage(bool* done, int64_t* usage_out, int64_t usage) {
   EXPECT_FALSE(*done);
   *done = true;
   *usage_out = usage;
 }
 
 }  // namespace
 
 class MockQuotaClient : public QuotaClient {
  public:
   MockQuotaClient() {}
   ~MockQuotaClient() override {}
 
   ID id() const override { return kFileSystem; }
 
   void OnQuotaManagerDestroyed() override {}
 
   void GetOriginUsage(const GURL& origin,
                       StorageType type,
                       const GetUsageCallback& callback) override {
     EXPECT_EQ(kStorageTypeTemporary, type);
-    int64 usage = GetUsage(origin);
+    int64_t usage = GetUsage(origin);
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                   base::Bind(callback, usage));
   }
 
   void GetOriginsForType(StorageType type,
                          const GetOriginsCallback& callback) override {
     EXPECT_EQ(kStorageTypeTemporary, type);
     std::set<GURL> origins;
     for (UsageMap::const_iterator itr = usage_map_.begin();
          itr != usage_map_.end(); ++itr) {
@@ skipping 23 matching lines @@
     EXPECT_EQ(kStorageTypeTemporary, type);
     usage_map_.erase(origin);
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, kQuotaStatusOk));
   }
 
   bool DoesSupport(storage::StorageType type) const override {
     return type == storage::kStorageTypeTemporary;
   }
 
-  int64 GetUsage(const GURL& origin) {
+  int64_t GetUsage(const GURL& origin) {
     UsageMap::const_iterator found = usage_map_.find(origin);
     if (found == usage_map_.end())
       return 0;
     return found->second;
   }
 
-  void SetUsage(const GURL& origin, int64 usage) {
+  void SetUsage(const GURL& origin, int64_t usage) {
     usage_map_[origin] = usage;
   }
 
-  int64 UpdateUsage(const GURL& origin, int64 delta) {
+  int64_t UpdateUsage(const GURL& origin, int64_t delta) {
     return usage_map_[origin] += delta;
   }
 
  private:
-  typedef std::map<GURL, int64> UsageMap;
+  typedef std::map<GURL, int64_t> UsageMap;
 
   UsageMap usage_map_;
 
   DISALLOW_COPY_AND_ASSIGN(MockQuotaClient);
 };
 
 class UsageTrackerTest : public testing::Test {
  public:
   UsageTrackerTest()
       : storage_policy_(new MockSpecialStoragePolicy()),
         usage_tracker_(GetUsageTrackerList(), kStorageTypeTemporary,
                        storage_policy_.get(), NULL) {
   }
 
   ~UsageTrackerTest() override {}
 
   UsageTracker* usage_tracker() {
     return &usage_tracker_;
   }
 
-  void UpdateUsage(const GURL& origin, int64 delta) {
+  void UpdateUsage(const GURL& origin, int64_t delta) {
     quota_client_.UpdateUsage(origin, delta);
     usage_tracker_.UpdateUsageCache(quota_client_.id(), origin, delta);
     base::RunLoop().RunUntilIdle();
   }
 
-  void UpdateUsageWithoutNotification(const GURL& origin, int64 delta) {
+  void UpdateUsageWithoutNotification(const GURL& origin, int64_t delta) {
     quota_client_.UpdateUsage(origin, delta);
   }
 
-  void GetGlobalLimitedUsage(int64* limited_usage) {
+  void GetGlobalLimitedUsage(int64_t* limited_usage) {
     bool done = false;
     usage_tracker_.GetGlobalLimitedUsage(base::Bind(
         &DidGetUsage, &done, limited_usage));
     base::RunLoop().RunUntilIdle();
 
     EXPECT_TRUE(done);
   }
 
-  void GetGlobalUsage(int64* usage, int64* unlimited_usage) {
+  void GetGlobalUsage(int64_t* usage, int64_t* unlimited_usage) {
     bool done = false;
     usage_tracker_.GetGlobalUsage(base::Bind(
         &DidGetGlobalUsage,
         &done, usage, unlimited_usage));
     base::RunLoop().RunUntilIdle();
 
     EXPECT_TRUE(done);
   }
 
-  void GetHostUsage(const std::string& host, int64* usage) {
+  void GetHostUsage(const std::string& host, int64_t* usage) {
     bool done = false;
     usage_tracker_.GetHostUsage(host, base::Bind(&DidGetUsage, &done, usage));
     base::RunLoop().RunUntilIdle();
 
     EXPECT_TRUE(done);
   }
 
   void GrantUnlimitedStoragePolicy(const GURL& origin) {
     if (!storage_policy_->IsStorageUnlimited(origin)) {
       storage_policy_->AddUnlimited(origin);
@@ skipping 25 matching lines @@
   base::MessageLoop message_loop_;
 
   scoped_refptr<MockSpecialStoragePolicy> storage_policy_;
   MockQuotaClient quota_client_;
   UsageTracker usage_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(UsageTrackerTest);
 };
 
 TEST_F(UsageTrackerTest, GrantAndRevokeUnlimitedStorage) {
-  int64 usage = 0;
-  int64 unlimited_usage = 0;
-  int64 host_usage = 0;
+  int64_t usage = 0;
+  int64_t unlimited_usage = 0;
+  int64_t host_usage = 0;
   GetGlobalUsage(&usage, &unlimited_usage);
   EXPECT_EQ(0, usage);
   EXPECT_EQ(0, unlimited_usage);
 
   const GURL origin("http://example.com");
   const std::string host(net::GetHostOrSpecFromURL(origin));
 
   UpdateUsage(origin, 100);
   GetGlobalUsage(&usage, &unlimited_usage);
   GetHostUsage(host, &host_usage);
@@ skipping 10 matching lines @@
 
   RevokeUnlimitedStoragePolicy(origin);
   GetGlobalUsage(&usage, &unlimited_usage);
   GetHostUsage(host, &host_usage);
   EXPECT_EQ(100, usage);
   EXPECT_EQ(0, unlimited_usage);
   EXPECT_EQ(100, host_usage);
 }
 
 TEST_F(UsageTrackerTest, CacheDisabledClientTest) {
-  int64 usage = 0;
-  int64 unlimited_usage = 0;
-  int64 host_usage = 0;
+  int64_t usage = 0;
+  int64_t unlimited_usage = 0;
+  int64_t host_usage = 0;
 
   const GURL origin("http://example.com");
   const std::string host(net::GetHostOrSpecFromURL(origin));
 
   UpdateUsage(origin, 100);
   GetGlobalUsage(&usage, &unlimited_usage);
   GetHostUsage(host, &host_usage);
   EXPECT_EQ(100, usage);
   EXPECT_EQ(0, unlimited_usage);
   EXPECT_EQ(100, host_usage);
@@ skipping 43 matching lines @@
   GrantUnlimitedStoragePolicy(kNonCachedUnlimited);
 
   SetUsageCacheEnabled(kNonCached, false);
   SetUsageCacheEnabled(kNonCachedUnlimited, false);
 
   UpdateUsageWithoutNotification(kNormal, 1);
   UpdateUsageWithoutNotification(kUnlimited, 2);
   UpdateUsageWithoutNotification(kNonCached, 4);
   UpdateUsageWithoutNotification(kNonCachedUnlimited, 8);
 
-  int64 limited_usage = 0;
-  int64 total_usage = 0;
-  int64 unlimited_usage = 0;
+  int64_t limited_usage = 0;
+  int64_t total_usage = 0;
+  int64_t unlimited_usage = 0;
 
   GetGlobalLimitedUsage(&limited_usage);
   GetGlobalUsage(&total_usage, &unlimited_usage);
   EXPECT_EQ(1 + 4, limited_usage);
   EXPECT_EQ(1 + 2 + 4 + 8, total_usage);
   EXPECT_EQ(2 + 8, unlimited_usage);
 
   UpdateUsageWithoutNotification(kNonCached, 16 - 4);
   UpdateUsageWithoutNotification(kNonCachedUnlimited, 32 - 8);
 
   GetGlobalLimitedUsage(&limited_usage);
   GetGlobalUsage(&total_usage, &unlimited_usage);
   EXPECT_EQ(1 + 16, limited_usage);
   EXPECT_EQ(1 + 2 + 16 + 32, total_usage);
   EXPECT_EQ(2 + 32, unlimited_usage);
 }
 
 
 }  // namespace content