Remove kint32max.

net/http/mock_http_cache.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/http/mock_http_cache.h"
 
+#include <limits>
+
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
@@ skipping 62 matching lines @@
 }
 
 base::Time MockDiskEntry::GetLastUsed() const {
   return base::Time::FromInternalValue(0);
 }
 
 base::Time MockDiskEntry::GetLastModified() const {
   return base::Time::FromInternalValue(0);
 }
 
-int32 MockDiskEntry::GetDataSize(int index) const {
+int32_t MockDiskEntry::GetDataSize(int index) const {
   DCHECK(index >= 0 && index < kNumCacheEntryDataIndices);
-  return static_cast<int32>(data_[index].size());
+  return static_cast<int32_t>(data_[index].size());
 }
 
 int MockDiskEntry::ReadData(int index,
                             int offset,
                             IOBuffer* buf,
                             int buf_len,
                             const CompletionCallback& callback) {
   DCHECK(index >= 0 && index < kNumCacheEntryDataIndices);
   DCHECK(!callback.is_null());
 
@@ skipping 37 matching lines @@
   if (buf_len)
     memcpy(&data_[index][offset], buf->data(), buf_len);
 
   if (MockHttpCache::GetTestMode(test_mode_) & TEST_MODE_SYNC_CACHE_WRITE)
     return buf_len;
 
   CallbackLater(callback, buf_len);
   return ERR_IO_PENDING;
 }
 
-int MockDiskEntry::ReadSparseData(int64 offset,
+int MockDiskEntry::ReadSparseData(int64_t offset,
                                   IOBuffer* buf,
                                   int buf_len,
                                   const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   if (fail_sparse_requests_)
     return ERR_NOT_IMPLEMENTED;
   if (!sparse_ || busy_ || cancel_)
     return ERR_CACHE_OPERATION_NOT_SUPPORTED;
   if (offset < 0)
     return ERR_FAILED;
 
   if (fail_requests_)
     return ERR_CACHE_READ_FAILURE;
 
-  DCHECK(offset < kint32max);
+  DCHECK(offset < std::numeric_limits<int32_t>::max());
   int real_offset = static_cast<int>(offset);
   if (!buf_len)
     return 0;
 
   int num = std::min(static_cast<int>(data_[1].size()) - real_offset,
                      buf_len);
   memcpy(buf->data(), &data_[1][real_offset], num);
 
   if (MockHttpCache::GetTestMode(test_mode_) & TEST_MODE_SYNC_CACHE_READ)
     return num;
 
   CallbackLater(callback, num);
   busy_ = true;
   delayed_ = false;
   return ERR_IO_PENDING;
 }
 
-int MockDiskEntry::WriteSparseData(int64 offset,
+int MockDiskEntry::WriteSparseData(int64_t offset,
                                    IOBuffer* buf,
                                    int buf_len,
                                    const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   if (fail_sparse_requests_)
     return ERR_NOT_IMPLEMENTED;
   if (busy_ || cancel_)
     return ERR_CACHE_OPERATION_NOT_SUPPORTED;
   if (!sparse_) {
     if (data_[1].size())
       return ERR_CACHE_OPERATION_NOT_SUPPORTED;
     sparse_ = true;
   }
   if (offset < 0)
     return ERR_FAILED;
   if (!buf_len)
     return 0;
 
   if (fail_requests_)
     return ERR_CACHE_READ_FAILURE;
 
-  DCHECK(offset < kint32max);
+  DCHECK(offset < std::numeric_limits<int32_t>::max());
   int real_offset = static_cast<int>(offset);
 
   if (static_cast<int>(data_[1].size()) < real_offset + buf_len)
     data_[1].resize(real_offset + buf_len);
 
   memcpy(&data_[1][real_offset], buf->data(), buf_len);
   if (MockHttpCache::GetTestMode(test_mode_) & TEST_MODE_SYNC_CACHE_WRITE)
     return buf_len;
 
   CallbackLater(callback, buf_len);
   return ERR_IO_PENDING;
 }
 
-int MockDiskEntry::GetAvailableRange(int64 offset,
+int MockDiskEntry::GetAvailableRange(int64_t offset,
                                      int len,
-                                     int64* start,
+                                     int64_t* start,
                                      const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   if (!sparse_ || busy_ || cancel_)
     return ERR_CACHE_OPERATION_NOT_SUPPORTED;
   if (offset < 0)
     return ERR_FAILED;
 
   if (fail_requests_)
     return ERR_CACHE_READ_FAILURE;
 
   *start = offset;
-  DCHECK(offset < kint32max);
+  DCHECK(offset < std::numeric_limits<int32_t>::max());
   int real_offset = static_cast<int>(offset);
   if (static_cast<int>(data_[1].size()) < real_offset)
     return 0;
 
   int num = std::min(static_cast<int>(data_[1].size()) - real_offset, len);
   int count = 0;
   for (; num > 0; num--, real_offset++) {
     if (!count) {
       if (data_[1][real_offset]) {
         count++;
@@ skipping 118 matching lines @@
 }
 
 MockDiskCache::~MockDiskCache() {
   ReleaseAll();
 }
 
 CacheType MockDiskCache::GetCacheType() const {
   return DISK_CACHE;
 }
 
-int32 MockDiskCache::GetEntryCount() const {
-  return static_cast<int32>(entries_.size());
+int32_t MockDiskCache::GetEntryCount() const {
+  return static_cast<int32_t>(entries_.size());
 }
 
 int MockDiskCache::OpenEntry(const std::string& key,
                              disk_cache::Entry** entry,
                              const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   if (fail_requests_)
     return ERR_CACHE_OPEN_FAILURE;
 
   EntryMap::iterator it = entries_.find(key);
@@ skipping 284 matching lines @@
   if (!callback_.is_null()) {
     if (!fail_)
       backend_->reset(new MockDiskCache());
     CompletionCallback cb = callback_;
     callback_.Reset();
     cb.Run(Result());  // This object can be deleted here.
   }
 }
 
 }  // namespace net