Switch to standard integer types in content/browser/.

content/browser/appcache/appcache_quota_client_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 <map>
 #include <set>
 
 #include "base/bind.h"
 #include "base/run_loop.h"
 #include "content/browser/appcache/appcache_quota_client.h"
 #include "content/browser/appcache/mock_appcache_service.h"
 #include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 14 matching lines @@
       : kOriginA("http://host"),
         kOriginB("http://host:8000"),
         kOriginOther("http://other"),
         usage_(0),
         delete_status_(storage::kQuotaStatusUnknown),
         num_get_origin_usage_completions_(0),
         num_get_origins_completions_(0),
         num_delete_origins_completions_(0),
         weak_factory_(this) {}
 
-  int64 GetOriginUsage(storage::QuotaClient* client,
-                       const GURL& origin,
-                       storage::StorageType type) {
+  int64_t GetOriginUsage(storage::QuotaClient* client,
+                         const GURL& origin,
+                         storage::StorageType type) {
     usage_ = -1;
     AsyncGetOriginUsage(client, origin, type);
     base::RunLoop().RunUntilIdle();
     return usage_;
   }
 
   const std::set<GURL>& GetOriginsForType(storage::QuotaClient* client,
                                           storage::StorageType type) {
     origins_.clear();
     AsyncGetOriginsForType(client, type);
@@ skipping 47 matching lines @@
 
   void AsyncDeleteOriginData(storage::QuotaClient* client,
                              storage::StorageType type,
                              const GURL& origin) {
     client->DeleteOriginData(
         origin, type,
         base::Bind(&AppCacheQuotaClientTest::OnDeleteOriginDataComplete,
                    weak_factory_.GetWeakPtr()));
   }
 
-  void SetUsageMapEntry(const GURL& origin, int64 usage) {
+  void SetUsageMapEntry(const GURL& origin, int64_t usage) {
     mock_service_.storage()->usage_map_[origin] = usage;
   }
 
   AppCacheQuotaClient* CreateClient() {
     return new AppCacheQuotaClient(&mock_service_);
   }
 
   void Call_NotifyAppCacheReady(AppCacheQuotaClient* client) {
     client->NotifyAppCacheReady();
   }
 
   void Call_NotifyAppCacheDestroyed(AppCacheQuotaClient* client) {
     client->NotifyAppCacheDestroyed();
   }
 
   void Call_OnQuotaManagerDestroyed(AppCacheQuotaClient* client) {
     client->OnQuotaManagerDestroyed();
   }
 
  protected:
-  void OnGetOriginUsageComplete(int64 usage) {
+  void OnGetOriginUsageComplete(int64_t usage) {
     ++num_get_origin_usage_completions_;
     usage_ = usage;
   }
 
   void OnGetOriginsComplete(const std::set<GURL>& origins) {
     ++num_get_origins_completions_;
     origins_ = origins;
   }
 
   void OnDeleteOriginDataComplete(storage::QuotaStatusCode status) {
     ++num_delete_origins_completions_;
     delete_status_ = status;
   }
 
   base::MessageLoop message_loop_;
-  int64 usage_;
+  int64_t usage_;
   std::set<GURL> origins_;
   storage::QuotaStatusCode delete_status_;
   int num_get_origin_usage_completions_;
   int num_get_origins_completions_;
   int num_delete_origins_completions_;
   MockAppCacheService mock_service_;
   base::WeakPtrFactory<AppCacheQuotaClientTest> weak_factory_;
 };
 
 
@@ skipping 257 matching lines @@
   // A real completion callback from the service should
   // be dropped if it comes in after NotifyAppCacheDestroyed.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, num_delete_origins_completions_);
   EXPECT_EQ(storage::kQuotaErrorAbort, delete_status_);
 
   Call_OnQuotaManagerDestroyed(client);
 }
 
 }  // namespace content