Switch to standard integer types in net/.

net/disk_cache/memory/mem_entry_impl.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/memory/mem_entry_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/memory/mem_backend_impl.h"
 #include "net/disk_cache/net_log_parameters.h"
 
 using base::Time;
 
 namespace {
 
 const int kSparseData = 1;
 
 // Maximum size of a sparse entry is 2 to the power of this number.
 const int kMaxSparseEntryBits = 12;
 
 // Sparse entry has maximum size of 4KB.
 const int kMaxSparseEntrySize = 1 << kMaxSparseEntryBits;
 
 // Convert global offset to child index.
-inline int ToChildIndex(int64 offset) {
+inline int ToChildIndex(int64_t offset) {
   return static_cast<int>(offset >> kMaxSparseEntryBits);
 }
 
 // Convert global offset to offset in child entry.
-inline int ToChildOffset(int64 offset) {
+inline int ToChildOffset(int64_t offset) {
   return static_cast<int>(offset & (kMaxSparseEntrySize - 1));
 }
 
 // Returns a name for a child entry given the base_name of the parent and the
 // child_id.  This name is only used for logging purposes.
 // If the entry is called entry_name, child entries will be named something
 // like Range_entry_name:YYY where YYY is the number of the particular child.
 std::string GenerateChildName(const std::string& base_name, int child_id) {
   return base::StringPrintf("Range_%s:%i", base_name.c_str(), child_id);
 }
@@ skipping 36 matching lines @@
   last_used_ = current;
 
   net_log_ = net::BoundNetLog::Make(net_log,
                                     net::NetLog::SOURCE_MEMORY_CACHE_ENTRY);
   // Must be called after |key_| is set, so GetKey() works.
   net_log_.BeginEvent(
       net::NetLog::TYPE_DISK_CACHE_MEM_ENTRY_IMPL,
       CreateNetLogEntryCreationCallback(this, true));
 
   Open();
-  backend_->ModifyStorageSize(0, static_cast<int32>(key.size()));
+  backend_->ModifyStorageSize(0, static_cast<int32_t>(key.size()));
   return true;
 }
 
 void MemEntryImpl::InternalDoom() {
   net_log_.AddEvent(net::NetLog::TYPE_ENTRY_DOOM);
   doomed_ = true;
   if (!ref_count_) {
     if (type() == kParentEntry) {
       // If this is a parent entry, we need to doom all the child entries.
       if (children_.get()) {
@@ skipping 68 matching lines @@
 }
 
 Time MemEntryImpl::GetLastUsed() const {
   return last_used_;
 }
 
 Time MemEntryImpl::GetLastModified() const {
   return last_modified_;
 }
 
-int32 MemEntryImpl::GetDataSize(int index) const {
+int32_t MemEntryImpl::GetDataSize(int index) const {
   if (index < 0 || index >= NUM_STREAMS)
     return 0;
   return data_size_[index];
 }
 
 int MemEntryImpl::ReadData(int index, int offset, IOBuffer* buf, int buf_len,
                            const CompletionCallback& callback) {
   if (net_log_.IsCapturing()) {
     net_log_.BeginEvent(
         net::NetLog::TYPE_ENTRY_READ_DATA,
@@ skipping 21 matching lines @@
   int result = InternalWriteData(index, offset, buf, buf_len, truncate);
 
   if (net_log_.IsCapturing()) {
     net_log_.EndEvent(
         net::NetLog::TYPE_ENTRY_WRITE_DATA,
         CreateNetLogReadWriteCompleteCallback(result));
   }
   return result;
 }
 
-int MemEntryImpl::ReadSparseData(int64 offset, IOBuffer* buf, int buf_len,
+int MemEntryImpl::ReadSparseData(int64_t offset,
+                                 IOBuffer* buf,
+                                 int buf_len,
                                  const CompletionCallback& callback) {
   if (net_log_.IsCapturing()) {
     net_log_.BeginEvent(
         net::NetLog::TYPE_SPARSE_READ,
         CreateNetLogSparseOperationCallback(offset, buf_len));
   }
   int result = InternalReadSparseData(offset, buf, buf_len);
   if (net_log_.IsCapturing())
     net_log_.EndEvent(net::NetLog::TYPE_SPARSE_READ);
   return result;
 }
 
-int MemEntryImpl::WriteSparseData(int64 offset, IOBuffer* buf, int buf_len,
+int MemEntryImpl::WriteSparseData(int64_t offset,
+                                  IOBuffer* buf,
+                                  int buf_len,
                                   const CompletionCallback& callback) {
   if (net_log_.IsCapturing()) {
     net_log_.BeginEvent(
         net::NetLog::TYPE_SPARSE_WRITE,
         CreateNetLogSparseOperationCallback(offset, buf_len));
   }
   int result = InternalWriteSparseData(offset, buf, buf_len);
   if (net_log_.IsCapturing())
     net_log_.EndEvent(net::NetLog::TYPE_SPARSE_WRITE);
   return result;
 }
 
-int MemEntryImpl::GetAvailableRange(int64 offset, int len, int64* start,
+int MemEntryImpl::GetAvailableRange(int64_t offset,
+                                    int len,
+                                    int64_t* start,
                                     const CompletionCallback& callback) {
   if (net_log_.IsCapturing()) {
     net_log_.BeginEvent(
         net::NetLog::TYPE_SPARSE_GET_RANGE,
         CreateNetLogSparseOperationCallback(offset, len));
   }
   int result = GetAvailableRange(offset, len, start);
   if (net_log_.IsCapturing()) {
     net_log_.EndEvent(
         net::NetLog::TYPE_SPARSE_GET_RANGE,
         CreateNetLogGetAvailableRangeResultCallback(*start, result));
   }
   return result;
 }
 
 bool MemEntryImpl::CouldBeSparse() const {
   DCHECK_EQ(kParentEntry, type());
   return (children_.get() != NULL);
 }
 
 int MemEntryImpl::ReadyForSparseIO(const CompletionCallback& callback) {
   return net::OK;
 }
 
 // ------------------------------------------------------------------------
 
 MemEntryImpl::~MemEntryImpl() {
   for (int i = 0; i < NUM_STREAMS; i++)
     backend_->ModifyStorageSize(data_size_[i], 0);
-  backend_->ModifyStorageSize(static_cast<int32>(key_.size()), 0);
+  backend_->ModifyStorageSize(static_cast<int32_t>(key_.size()), 0);
   net_log_.EndEvent(net::NetLog::TYPE_DISK_CACHE_MEM_ENTRY_IMPL);
 }
 
 int MemEntryImpl::InternalReadData(int index, int offset, IOBuffer* buf,
                                    int buf_len) {
   DCHECK(type() == kParentEntry || index == kSparseData);
 
   if (index < 0 || index >= NUM_STREAMS)
     return net::ERR_INVALID_ARGUMENT;
 
@@ skipping 48 matching lines @@
 
   UpdateRank(true);
 
   if (!buf_len)
     return 0;
 
   memcpy(&(data_[index])[offset], buf->data(), buf_len);
   return buf_len;
 }
 
-int MemEntryImpl::InternalReadSparseData(int64 offset, IOBuffer* buf,
+int MemEntryImpl::InternalReadSparseData(int64_t offset,
+                                         IOBuffer* buf,
                                          int buf_len) {
   DCHECK(type() == kParentEntry);
 
   if (!InitSparseInfo())
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
   if (offset < 0 || buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   // We will keep using this buffer and adjust the offset in this buffer.
@@ skipping 36 matching lines @@
 
     // Increment the counter by number of bytes read in the child entry.
     io_buf->DidConsume(ret);
   }
 
   UpdateRank(false);
 
   return io_buf->BytesConsumed();
 }
 
-int MemEntryImpl::InternalWriteSparseData(int64 offset, IOBuffer* buf,
+int MemEntryImpl::InternalWriteSparseData(int64_t offset,
+                                          IOBuffer* buf,
                                           int buf_len) {
   DCHECK(type() == kParentEntry);
 
   if (!InitSparseInfo())
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
   if (offset < 0 || buf_len < 0)
     return net::ERR_INVALID_ARGUMENT;
 
   scoped_refptr<net::DrainableIOBuffer> io_buf(
@@ skipping 45 matching lines @@
 
     // Adjust the offset in the IO buffer.
     io_buf->DidConsume(ret);
   }
 
   UpdateRank(true);
 
   return io_buf->BytesConsumed();
 }
 
-int MemEntryImpl::GetAvailableRange(int64 offset, int len, int64* start) {
+int MemEntryImpl::GetAvailableRange(int64_t offset, int len, int64_t* start) {
   DCHECK(type() == kParentEntry);
   DCHECK(start);
 
   if (!InitSparseInfo())
     return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
 
   if (offset < 0 || len < 0 || !start)
     return net::ERR_INVALID_ARGUMENT;
 
   MemEntryImpl* current_child = NULL;
@@ skipping 89 matching lines @@
   parent_ = parent;
   child_id_ = child_id;
   Time current = Time::Now();
   last_modified_ = current;
   last_used_ = current;
   // Insert this to the backend's ranking list.
   backend_->InsertIntoRankingList(this);
   return true;
 }
 
-MemEntryImpl* MemEntryImpl::OpenChild(int64 offset, bool create) {
+MemEntryImpl* MemEntryImpl::OpenChild(int64_t offset, bool create) {
   DCHECK(type() == kParentEntry);
   int index = ToChildIndex(offset);
   EntryMap::iterator i = children_->find(index);
   if (i != children_->end()) {
     return i->second;
   } else if (create) {
     MemEntryImpl* child = new MemEntryImpl(backend_);
     child->InitChildEntry(this, index, net_log_.net_log());
     (*children_)[index] = child;
     return child;
   }
   return NULL;
 }
 
-int MemEntryImpl::FindNextChild(int64 offset, int len, MemEntryImpl** child) {
+int MemEntryImpl::FindNextChild(int64_t offset, int len, MemEntryImpl** child) {
   DCHECK(child);
   *child = NULL;
   int scanned_len = 0;
 
   // This loop tries to find the first existing child.
   while (scanned_len < len) {
     // This points to the current offset in the child.
     int current_child_offset = ToChildOffset(offset + scanned_len);
     MemEntryImpl* current_child = OpenChild(offset + scanned_len, false);
     if (current_child) {
@@ skipping 16 matching lines @@
     scanned_len += kMaxSparseEntrySize - current_child_offset;
   }
   return scanned_len;
 }
 
 void MemEntryImpl::DetachChild(int child_id) {
   children_->erase(child_id);
 }
 
 }  // namespace disk_cache