Switch to standard integer types in net/.

net/disk_cache/blockfile/sparse_control_v3.cc

 // Copyright (c) 2012 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 "net/disk_cache/blockfile/sparse_control.h"
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/blockfile/backend_impl.h"
 #include "net/disk_cache/blockfile/entry_impl.h"
 #include "net/disk_cache/blockfile/file.h"
 #include "net/disk_cache/net_log_parameters.h"
@@ skipping 15 matching lines @@
 const int kMaxEntrySize = 0x100000;
 
 // The size of each data block (tracked by the child allocation bitmap).
 const int kBlockSize = 1024;
 
 // Returns the name of a child entry given the base_name and signature of the
 // parent and the child_id.
 // If the entry is called entry_name, child entries will be named something
 // like Range_entry_name:XXX:YYY where XXX is the entry signature and YYY is the
 // number of the particular child.
-std::string GenerateChildName(const std::string& base_name, int64 signature,
-                              int64 child_id) {
+std::string GenerateChildName(const std::string& base_name,
+                              int64_t signature,
+                              int64_t child_id) {
   return base::StringPrintf("Range_%s:%" PRIx64 ":%" PRIx64, base_name.c_str(),
                             signature, child_id);
 }
 
 // This class deletes the children of a sparse entry.
 class ChildrenDeleter
     : public base::RefCounted<ChildrenDeleter>,
       public disk_cache::FileIOCallback {
  public:
   ChildrenDeleter(disk_cache::BackendImpl* backend, const std::string& name)
       : backend_(backend->GetWeakPtr()), name_(name), signature_(0) {}
 
   void OnFileIOComplete(int bytes_copied) override;
 
   // Two ways of deleting the children: if we have the children map, use Start()
   // directly, otherwise pass the data address to ReadData().
   void Start(char* buffer, int len);
   void ReadData(disk_cache::Addr address, int len);
 
  private:
   friend class base::RefCounted<ChildrenDeleter>;
   ~ChildrenDeleter() override {}
 
   void DeleteChildren();
 
   base::WeakPtr<disk_cache::BackendImpl> backend_;
   std::string name_;
   disk_cache::Bitmap children_map_;
-  int64 signature_;
+  int64_t signature_;
   scoped_ptr<char[]> buffer_;
   DISALLOW_COPY_AND_ASSIGN(ChildrenDeleter);
 };
 
 // This is the callback of the file operation.
 void ChildrenDeleter::OnFileIOComplete(int bytes_copied) {
   char* buffer = buffer_.release();
   Start(buffer, bytes_copied);
 }
 
@@ skipping 129 matching lines @@
 bool SparseControl::CouldBeSparse() const {
   DCHECK(!init_);
 
   if (entry_->GetDataSize(kSparseData))
     return false;
 
   // We don't verify the data, just see if it could be there.
   return (entry_->GetDataSize(kSparseIndex) != 0);
 }
 
-int SparseControl::StartIO(SparseOperation op, int64 offset, net::IOBuffer* buf,
-                           int buf_len, const CompletionCallback& callback) {
+int SparseControl::StartIO(SparseOperation op,
+                           int64_t offset,
+                           net::IOBuffer* buf,
+                           int buf_len,
+                           const CompletionCallback& callback) {
   DCHECK(init_);
   // We don't support simultaneous IO for sparse data.
   if (operation_ != kNoOperation)
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
   if (offset < 0 || buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   // We only support up to 64 GB.
   if (offset + buf_len >= 0x1000000000LL || offset + buf_len < 0)
@@ skipping 28 matching lines @@
     // Everything was done synchronously.
     operation_ = kNoOperation;
     user_buf_ = NULL;
     user_callback_.Reset();
     return result_;
   }
 
   return net::ERR_IO_PENDING;
 }
 
-int SparseControl::GetAvailableRange(int64 offset, int len, int64* start) {
+int SparseControl::GetAvailableRange(int64_t offset, int len, int64_t* start) {
   DCHECK(init_);
   // We don't support simultaneous IO for sparse data.
   if (operation_ != kNoOperation)
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
   DCHECK(start);
 
   range_found_ = false;
   int result = StartIO(
       kGetRangeOperation, offset, NULL, len, CompletionCallback());
@@ skipping 146 matching lines @@
 
   // Read the actual bitmap.
   buf = new net::IOBuffer(map_len);
   rv = entry_->ReadData(kSparseIndex, sizeof(sparse_header_), buf.get(),
                         map_len, CompletionCallback());
   if (rv != map_len)
     return net::ERR_CACHE_READ_FAILURE;
 
   // Grow the bitmap to the current size and copy the bits.
   children_map_.Resize(map_len * 8, false);
-  children_map_.SetMap(reinterpret_cast<uint32*>(buf->data()), map_len);
+  children_map_.SetMap(reinterpret_cast<uint32_t*>(buf->data()), map_len);
   return net::OK;
 }
 
 bool SparseControl::OpenChild() {
   DCHECK_GE(result_, 0);
 
   std::string key = GenerateChildKey();
   if (child_) {
     // Keep using the same child or open another one?.
     if (key == child_->GetKey())
@@ skipping 406 matching lines @@
       DoAbortCallbacks();
     return;
   }
 
   // We are running a callback from the message loop. It's time to restart what
   // we were doing before.
   DoChildrenIO();
 }
 
 }  // namespace disk_cache