Switch to standard integer types in content/browser/.

content/browser/cache_storage/cache_storage_cache_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_cache.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/string_split.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
 #include "content/browser/fileapi/mock_url_request_delegate.h"
 #include "content/browser/quota/mock_quota_manager_proxy.h"
 #include "content/common/cache_storage/cache_storage_types.h"
 #include "content/common/service_worker/service_worker_types.h"
@@ skipping 31 matching lines @@
 // A disk_cache::Backend wrapper that can delay operations.
 class DelayableBackend : public disk_cache::Backend {
  public:
   DelayableBackend(scoped_ptr<disk_cache::Backend> backend)
       : backend_(backend.Pass()), delay_open_(false) {}
 
   // disk_cache::Backend overrides
   net::CacheType GetCacheType() const override {
     return backend_->GetCacheType();
   }
-  int32 GetEntryCount() const override { return backend_->GetEntryCount(); }
+  int32_t GetEntryCount() const override { return backend_->GetEntryCount(); }
   int OpenEntry(const std::string& key,
                 disk_cache::Entry** entry,
                 const CompletionCallback& callback) override {
     if (delay_open_) {
       open_entry_callback_ =
           base::Bind(&DelayableBackend::OpenEntryDelayedImpl,
                      base::Unretained(this), key, entry, callback);
       return net::ERR_IO_PENDING;
     }
 
@@ skipping 61 matching lines @@
   scoped_ptr<storage::BlobDataSnapshot> data = blob_handle.CreateSnapshot();
   const auto& items = data->items();
   for (const auto& item : items) {
     switch (item->type()) {
       case storage::DataElement::TYPE_BYTES: {
         output->append(item->bytes(), item->length());
         break;
       }
       case storage::DataElement::TYPE_DISK_CACHE_ENTRY: {
         disk_cache::Entry* entry = item->disk_cache_entry();
-        int32 body_size = entry->GetDataSize(item->disk_cache_stream_index());
+        int32_t body_size = entry->GetDataSize(item->disk_cache_stream_index());
 
         scoped_refptr<net::IOBuffer> io_buffer = new net::IOBuffer(body_size);
         net::TestCompletionCallback callback;
         int rv =
             entry->ReadData(item->disk_cache_stream_index(), 0, io_buffer.get(),
                             body_size, callback.callback());
         if (rv == net::ERR_IO_PENDING)
           rv = callback.WaitForResult();
         EXPECT_EQ(body_size, rv);
         if (rv > 0)
@@ skipping 752 matching lines @@
   request.headers["Content-Type"] = "bar";
   EXPECT_EQ("bar", request.headers["content-type"]);
 }
 
 TEST_P(CacheStorageCacheTestP, QuotaManagerModified) {
   EXPECT_EQ(0, quota_manager_proxy_->notify_storage_modified_count());
 
   EXPECT_TRUE(Put(no_body_request_, no_body_response_));
   EXPECT_EQ(1, quota_manager_proxy_->notify_storage_modified_count());
   EXPECT_LT(0, quota_manager_proxy_->last_notified_delta());
-  int64 sum_delta = quota_manager_proxy_->last_notified_delta();
+  int64_t sum_delta = quota_manager_proxy_->last_notified_delta();
 
   EXPECT_TRUE(Put(body_request_, body_response_));
   EXPECT_EQ(2, quota_manager_proxy_->notify_storage_modified_count());
   EXPECT_LT(sum_delta, quota_manager_proxy_->last_notified_delta());
   sum_delta += quota_manager_proxy_->last_notified_delta();
 
   EXPECT_TRUE(Delete(body_request_));
   EXPECT_EQ(3, quota_manager_proxy_->notify_storage_modified_count());
   sum_delta += quota_manager_proxy_->last_notified_delta();
 
   EXPECT_TRUE(Delete(no_body_request_));
   EXPECT_EQ(4, quota_manager_proxy_->notify_storage_modified_count());
   sum_delta += quota_manager_proxy_->last_notified_delta();
 
   EXPECT_EQ(0, sum_delta);
 }
 
 TEST_F(CacheStorageCacheMemoryOnlyTest, MemoryBackedSize) {
   EXPECT_EQ(0, cache_->MemoryBackedSize());
   EXPECT_TRUE(Put(no_body_request_, no_body_response_));
   EXPECT_LT(0, cache_->MemoryBackedSize());
-  int64 no_body_size = cache_->MemoryBackedSize();
+  int64_t no_body_size = cache_->MemoryBackedSize();
 
   EXPECT_TRUE(Delete(no_body_request_));
   EXPECT_EQ(0, cache_->MemoryBackedSize());
 
   EXPECT_TRUE(Put(body_request_, body_response_));
   EXPECT_LT(no_body_size, cache_->MemoryBackedSize());
 
   EXPECT_TRUE(Delete(body_request_));
   EXPECT_EQ(0, cache_->MemoryBackedSize());
 }
@@ skipping 62 matching lines @@
   EXPECT_EQ(1, sequence_out);
   close_loop2->Run();
   EXPECT_EQ(2, sequence_out);
 }
 
 INSTANTIATE_TEST_CASE_P(CacheStorageCacheTest,
                         CacheStorageCacheTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content