Remove kuint32max.

net/disk_cache/blockfile/file_posix.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/file.h"
 
+#include <stdint.h>
+
+#include <limits>
+
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/run_loop.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 
@@ skipping 32 matching lines @@
   base_file_.Initialize(name, flags);
   return base_file_.IsValid();
 }
 
 bool File::IsValid() const {
   return base_file_.IsValid();
 }
 
 bool File::Read(void* buffer, size_t buffer_len, size_t offset) {
   DCHECK(base_file_.IsValid());
-  if (buffer_len > static_cast<size_t>(kint32max) ||
-      offset > static_cast<size_t>(kint32max)) {
+  if (buffer_len > static_cast<size_t>(std::numeric_limits<int32_t>::max()) ||
+      offset > static_cast<size_t>(std::numeric_limits<int32_t>::max())) {
     return false;
   }
 
   int ret = base_file_.Read(offset, static_cast<char*>(buffer), buffer_len);
   return (static_cast<size_t>(ret) == buffer_len);
 }
 
 bool File::Write(const void* buffer, size_t buffer_len, size_t offset) {
   DCHECK(base_file_.IsValid());
-  if (buffer_len > static_cast<size_t>(kint32max) ||
-      offset > static_cast<size_t>(kint32max)) {
+  if (buffer_len > static_cast<size_t>(std::numeric_limits<int32_t>::max()) ||
+      offset > static_cast<size_t>(std::numeric_limits<int32_t>::max())) {
     return false;
   }
 
   int ret = base_file_.Write(offset, static_cast<const char*>(buffer),
                              buffer_len);
   return (static_cast<size_t>(ret) == buffer_len);
 }
 
 bool File::Read(void* buffer, size_t buffer_len, size_t offset,
                 FileIOCallback* callback, bool* completed) {
   DCHECK(base_file_.IsValid());
   if (!callback) {
     if (completed)
       *completed = true;
     return Read(buffer, buffer_len, offset);
   }
 
-  if (buffer_len > static_cast<size_t>(kint32max) ||
-      offset > static_cast<size_t>(kint32max)) {
+  if (buffer_len > static_cast<size_t>(std::numeric_limits<int32_t>::max()) ||
+      offset > static_cast<size_t>(std::numeric_limits<int32_t>::max())) {
     return false;
   }
 
   base::PostTaskAndReplyWithResult(
       s_worker_pool.Pointer(), FROM_HERE,
       base::Bind(&File::DoRead, this, buffer, buffer_len, offset),
       base::Bind(&File::OnOperationComplete, this, callback));
 
   *completed = false;
   return true;
 }
 
 bool File::Write(const void* buffer, size_t buffer_len, size_t offset,
                  FileIOCallback* callback, bool* completed) {
   DCHECK(base_file_.IsValid());
   if (!callback) {
     if (completed)
       *completed = true;
     return Write(buffer, buffer_len, offset);
   }
 
-  if (buffer_len > static_cast<size_t>(kint32max) ||
-      offset > static_cast<size_t>(kint32max)) {
+  if (buffer_len > static_cast<size_t>(std::numeric_limits<int32_t>::max()) ||
+      offset > static_cast<size_t>(std::numeric_limits<int32_t>::max())) {
     return false;
   }
 
   base::PostTaskAndReplyWithResult(
       s_worker_pool.Pointer(), FROM_HERE,
       base::Bind(&File::DoWrite, this, buffer, buffer_len, offset),
       base::Bind(&File::OnOperationComplete, this, callback));
 
   *completed = false;
   return true;
 }
 
 bool File::SetLength(size_t length) {
   DCHECK(base_file_.IsValid());
-  if (length > kuint32max)
+  if (length > std::numeric_limits<uint32_t>::max())
     return false;
 
   return base_file_.SetLength(length);
 }
 
 size_t File::GetLength() {
   DCHECK(base_file_.IsValid());
-  int64 len = base_file_.GetLength();
+  int64_t len = base_file_.GetLength();
 
-  if (len > static_cast<int64>(kuint32max))
-    return kuint32max;
+  if (len > static_cast<int64_t>(std::numeric_limits<uint32_t>::max()))
+    return std::numeric_limits<uint32_t>::max();
 
   return static_cast<size_t>(len);
 }
 
 // Static.
 void File::WaitForPendingIO(int* num_pending_io) {
   // We are running unit tests so we should wait for all callbacks. Sadly, the
   // worker pool only waits for tasks on the worker pool, not the "Reply" tasks
   // so we have to let the current message loop to run.
   s_worker_pool.Get().FlushForTesting();
@@ skipping 28 matching lines @@
   return net::ERR_CACHE_WRITE_FAILURE;
 }
 
 // This method actually makes sure that the last reference to the file doesn't
 // go away on the worker pool.
 void File::OnOperationComplete(FileIOCallback* callback, int result) {
   callback->OnFileIOComplete(result);
 }
 
 }  // namespace disk_cache