Switch to standard integer types in content/browser/.

content/browser/cache_storage/cache_storage_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 "content/browser/cache_storage/cache_storage_manager.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/guid.h"
+#include "base/macros.h"
 #include "base/run_loop.h"
 #include "base/sha1.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/cache_storage/cache_storage.pb.h"
 #include "content/browser/cache_storage/cache_storage_quota_client.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
 #include "content/browser/quota/mock_quota_manager_proxy.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 235 matching lines @@
                             base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   CacheStorage* CacheStorageForOrigin(const GURL& origin) {
     return cache_manager_->FindOrCreateCacheStorage(origin);
   }
 
-  int64 GetOriginUsage(const GURL& origin) {
+  int64_t GetOriginUsage(const GURL& origin) {
     base::RunLoop loop;
     cache_manager_->GetOriginUsage(
         origin, base::Bind(&CacheStorageManagerTest::UsageCallback,
                            base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
     return callback_usage_;
   }
 
-  void UsageCallback(base::RunLoop* run_loop, int64 usage) {
+  void UsageCallback(base::RunLoop* run_loop, int64_t usage) {
     callback_usage_ = usage;
     run_loop->Quit();
   }
 
   std::vector<CacheStorageUsageInfo> GetAllOriginsUsage() {
     base::RunLoop loop;
     cache_manager_->GetAllOriginsUsage(
         base::Bind(&CacheStorageManagerTest::AllOriginsUsageCallback,
                    base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
@@ skipping 22 matching lines @@
   scoped_refptr<CacheStorageCache> callback_cache_;
   int callback_bool_;
   CacheStorageError callback_error_;
   scoped_ptr<ServiceWorkerResponse> callback_cache_response_;
   scoped_ptr<storage::BlobDataHandle> callback_data_handle_;
   std::vector<std::string> callback_strings_;
 
   const GURL origin1_;
   const GURL origin2_;
 
-  int64 callback_usage_;
+  int64_t callback_usage_;
   std::vector<CacheStorageUsageInfo> callback_all_origins_usage_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CacheStorageManagerTest);
 };
 
 class CacheStorageManagerMemoryOnlyTest : public CacheStorageManagerTest {
  public:
   bool MemoryOnly() override { return true; }
 };
@@ skipping 286 matching lines @@
   EXPECT_EQ(0, cache_storage->MemoryBackedSize());
 
   EXPECT_TRUE(Open(origin1_, "foo"));
   scoped_refptr<CacheStorageCache> foo_cache = callback_cache_;
   EXPECT_TRUE(Open(origin1_, "bar"));
   scoped_refptr<CacheStorageCache> bar_cache = callback_cache_;
   EXPECT_EQ(0, cache_storage->MemoryBackedSize());
 
   EXPECT_TRUE(CachePut(foo_cache, GURL("http://example.com/foo")));
   EXPECT_LT(0, cache_storage->MemoryBackedSize());
-  int64 foo_size = cache_storage->MemoryBackedSize();
+  int64_t foo_size = cache_storage->MemoryBackedSize();
 
   EXPECT_TRUE(CachePut(bar_cache, GURL("http://example.com/foo")));
   EXPECT_EQ(foo_size * 2, cache_storage->MemoryBackedSize());
 }
 
 TEST_F(CacheStorageManagerTest, MemoryBackedSizePersistent) {
   CacheStorage* cache_storage = CacheStorageForOrigin(origin1_);
   EXPECT_EQ(0, cache_storage->MemoryBackedSize());
   EXPECT_TRUE(Open(origin1_, "foo"));
   EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
@@ skipping 212 matching lines @@
 class CacheStorageQuotaClientTest : public CacheStorageManagerTest {
  protected:
   CacheStorageQuotaClientTest() {}
 
   void SetUp() override {
     CacheStorageManagerTest::SetUp();
     quota_client_.reset(
         new CacheStorageQuotaClient(cache_manager_->AsWeakPtr()));
   }
 
-  void QuotaUsageCallback(base::RunLoop* run_loop, int64 usage) {
+  void QuotaUsageCallback(base::RunLoop* run_loop, int64_t usage) {
     callback_quota_usage_ = usage;
     run_loop->Quit();
   }
 
   void OriginsCallback(base::RunLoop* run_loop, const std::set<GURL>& origins) {
     callback_origins_ = origins;
     run_loop->Quit();
   }
 
   void DeleteOriginCallback(base::RunLoop* run_loop,
                             storage::QuotaStatusCode status) {
     callback_status_ = status;
     run_loop->Quit();
   }
 
-  int64 QuotaGetOriginUsage(const GURL& origin) {
+  int64_t QuotaGetOriginUsage(const GURL& origin) {
     base::RunLoop loop;
     quota_client_->GetOriginUsage(
         origin, storage::kStorageTypeTemporary,
         base::Bind(&CacheStorageQuotaClientTest::QuotaUsageCallback,
                    base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
     return callback_quota_usage_;
   }
 
   size_t QuotaGetOriginsForType() {
@@ skipping 26 matching lines @@
     return callback_status_ == storage::kQuotaStatusOk;
   }
 
   bool QuotaDoesSupport(storage::StorageType type) {
     return quota_client_->DoesSupport(type);
   }
 
   scoped_ptr<CacheStorageQuotaClient> quota_client_;
 
   storage::QuotaStatusCode callback_status_;
-  int64 callback_quota_usage_ = 0;
+  int64_t callback_quota_usage_ = 0;
   std::set<GURL> callback_origins_;
 
   DISALLOW_COPY_AND_ASSIGN(CacheStorageQuotaClientTest);
 };
 
 class CacheStorageQuotaClientTestP : public CacheStorageQuotaClientTest,
                                      public testing::WithParamInterface<bool> {
   bool MemoryOnly() override { return !GetParam(); }
 };
 
@@ skipping 58 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(CacheStorageManagerTests,
                         CacheStorageManagerTestP,
                         ::testing::Values(false, true));
 
 INSTANTIATE_TEST_CASE_P(CacheStorageQuotaClientTests,
                         CacheStorageQuotaClientTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content