Remove kint32max.

content/browser/appcache/appcache_disk_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 "content/browser/appcache/appcache_disk_cache.h"
 
+#include <limits>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/base/cache_type.h"
 #include "net/base/net_errors.h"
@@ skipping 37 matching lines @@
   EntryImpl(disk_cache::Entry* disk_cache_entry,
             AppCacheDiskCache* owner)
       : disk_cache_entry_(disk_cache_entry), owner_(owner) {
     DCHECK(disk_cache_entry);
     DCHECK(owner);
     owner_->AddOpenEntry(this);
   }
 
   // Entry implementation.
   int Read(int index,
-           int64 offset,
+           int64_t offset,
            net::IOBuffer* buf,
            int buf_len,
            const net::CompletionCallback& callback) override {
-    if (offset < 0 || offset > kint32max)
+    if (offset < 0 || offset > std::numeric_limits<int32_t>::max())
       return net::ERR_INVALID_ARGUMENT;
     if (!disk_cache_entry_)
       return net::ERR_ABORTED;
     return disk_cache_entry_->ReadData(
         index, static_cast<int>(offset), buf, buf_len, callback);
   }
 
   int Write(int index,
-            int64 offset,
+            int64_t offset,
             net::IOBuffer* buf,
             int buf_len,
             const net::CompletionCallback& callback) override {
-    if (offset < 0 || offset > kint32max)
+    if (offset < 0 || offset > std::numeric_limits<int32_t>::max())
       return net::ERR_INVALID_ARGUMENT;
     if (!disk_cache_entry_)
       return net::ERR_ABORTED;
     const bool kTruncate = true;
     return disk_cache_entry_->WriteData(
         index, static_cast<int>(offset), buf, buf_len, callback, kTruncate);
   }
 
-  int64 GetSize(int index) override {
+  int64_t GetSize(int index) override {
     return disk_cache_entry_ ? disk_cache_entry_->GetDataSize(index) : 0L;
   }
 
   void Close() override {
     if (disk_cache_entry_)
       disk_cache_entry_->Close();
     delete this;
   }
 
   void Abandon() {
@@ skipping 11 matching lines @@
   disk_cache::Entry* disk_cache_entry_;
   AppCacheDiskCache* owner_;
 };
 
 // Separate object to hold state for each Create, Delete, or Doom call
 // while the call is in-flight and to produce an EntryImpl upon completion.
 class AppCacheDiskCache::ActiveCall
     : public base::RefCounted<AppCacheDiskCache::ActiveCall> {
  public:
   static int CreateEntry(const base::WeakPtr<AppCacheDiskCache>& owner,
-                         int64 key, Entry** entry,
+                         int64_t key,
+                         Entry** entry,
                          const net::CompletionCallback& callback) {
     scoped_refptr<ActiveCall> active_call(
         new ActiveCall(owner, entry, callback));
     int rv = owner->disk_cache()->CreateEntry(
         base::Int64ToString(key), &active_call->entry_ptr_,
         base::Bind(&ActiveCall::OnAsyncCompletion, active_call));
     return active_call->HandleImmediateReturnValue(rv);
   }
 
   static int OpenEntry(const base::WeakPtr<AppCacheDiskCache>& owner,
-                       int64 key, Entry** entry,
+                       int64_t key,
+                       Entry** entry,
                        const net::CompletionCallback& callback) {
     scoped_refptr<ActiveCall> active_call(
         new ActiveCall(owner, entry, callback));
     int rv = owner->disk_cache()->OpenEntry(
         base::Int64ToString(key), &active_call->entry_ptr_,
         base::Bind(&ActiveCall::OnAsyncCompletion, active_call));
     return active_call->HandleImmediateReturnValue(rv);
   }
 
   static int DoomEntry(const base::WeakPtr<AppCacheDiskCache>& owner,
-                       int64 key, const net::CompletionCallback& callback) {
+                       int64_t key,
+                       const net::CompletionCallback& callback) {
     scoped_refptr<ActiveCall> active_call(
         new ActiveCall(owner, nullptr, callback));
     int rv = owner->disk_cache()->DoomEntry(
         base::Int64ToString(key),
         base::Bind(&ActiveCall::OnAsyncCompletion, active_call));
     return active_call->HandleImmediateReturnValue(rv);
   }
 
  private:
   friend class base::RefCounted<AppCacheDiskCache::ActiveCall>;
@@ skipping 91 matching lines @@
   // appcache system on the fly. File handles held in both entries and in
   // the main disk_cache::Backend class need to be released.
   for (OpenEntries::const_iterator iter = open_entries_.begin();
        iter != open_entries_.end(); ++iter) {
     (*iter)->Abandon();
   }
   open_entries_.clear();
   disk_cache_.reset();
 }
 
-int AppCacheDiskCache::CreateEntry(int64 key, Entry** entry,
+int AppCacheDiskCache::CreateEntry(int64_t key,
+                                   Entry** entry,
                                    const net::CompletionCallback& callback) {
   DCHECK(entry);
   DCHECK(!callback.is_null());
   if (is_disabled_)
     return net::ERR_ABORTED;
 
   if (is_initializing_or_waiting_to_initialize()) {
     pending_calls_.push_back(PendingCall(CREATE, key, entry, callback));
     return net::ERR_IO_PENDING;
   }
 
   if (!disk_cache_)
     return net::ERR_FAILED;
 
   return ActiveCall::CreateEntry(
       weak_factory_.GetWeakPtr(), key, entry, callback);
 }
 
-int AppCacheDiskCache::OpenEntry(int64 key, Entry** entry,
+int AppCacheDiskCache::OpenEntry(int64_t key,
+                                 Entry** entry,
                                  const net::CompletionCallback& callback) {
   DCHECK(entry);
   DCHECK(!callback.is_null());
   if (is_disabled_)
     return net::ERR_ABORTED;
 
   if (is_initializing_or_waiting_to_initialize()) {
     pending_calls_.push_back(PendingCall(OPEN, key, entry, callback));
     return net::ERR_IO_PENDING;
   }
 
   if (!disk_cache_)
     return net::ERR_FAILED;
 
   return ActiveCall::OpenEntry(
       weak_factory_.GetWeakPtr(), key, entry, callback);
 }
 
-int AppCacheDiskCache::DoomEntry(int64 key,
+int AppCacheDiskCache::DoomEntry(int64_t key,
                                  const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   if (is_disabled_)
     return net::ERR_ABORTED;
 
   if (is_initializing_or_waiting_to_initialize()) {
     pending_calls_.push_back(PendingCall(DOOM, key, NULL, callback));
     return net::ERR_IO_PENDING;
   }
 
   if (!disk_cache_)
     return net::ERR_FAILED;
 
   return ActiveCall::DoomEntry(weak_factory_.GetWeakPtr(), key, callback);
 }
 
 AppCacheDiskCache::AppCacheDiskCache(bool use_simple_cache)
     : use_simple_cache_(use_simple_cache),
       is_disabled_(false),
       is_waiting_to_initialize_(false),
       weak_factory_(this) {
 }
 
 AppCacheDiskCache::PendingCall::PendingCall()
     : call_type(CREATE),
       key(0),
       entry(NULL) {
 }
 
-AppCacheDiskCache::PendingCall::PendingCall(PendingCallType call_type,
-    int64 key,
+AppCacheDiskCache::PendingCall::PendingCall(
+    PendingCallType call_type,
+    int64_t key,
     Entry** entry,
     const net::CompletionCallback& callback)
-    : call_type(call_type),
-      key(key),
-      entry(entry),
-      callback(callback) {
-}
+    : call_type(call_type), key(key), entry(entry), callback(callback) {}
 
 AppCacheDiskCache::PendingCall::~PendingCall() {}
 
 int AppCacheDiskCache::Init(
     net::CacheType cache_type,
     const base::FilePath& cache_directory,
     int cache_size,
     bool force,
     const scoped_refptr<base::SingleThreadTaskRunner>& cache_thread,
     const net::CompletionCallback& callback) {
@@ skipping 50 matching lines @@
         NOTREACHED();
         break;
     }
     if (rv != net::ERR_IO_PENDING)
       iter->callback.Run(rv);
   }
   pending_calls_.clear();
 }
 
 }  // namespace content