Remove kint32max.

content/browser/appcache/appcache_response.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_response.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
@@ skipping 29 matching lines @@
   ~WrappedPickleIOBuffer() override {}
 
   scoped_ptr<const base::Pickle> pickle_;
 };
 
 }  // anon namespace
 
 
 // AppCacheResponseInfo ----------------------------------------------
 
-AppCacheResponseInfo::AppCacheResponseInfo(
-    AppCacheStorage* storage, const GURL& manifest_url,
-    int64 response_id,  net::HttpResponseInfo* http_info,
-    int64 response_data_size)
-    : manifest_url_(manifest_url), response_id_(response_id),
-      http_response_info_(http_info), response_data_size_(response_data_size),
+AppCacheResponseInfo::AppCacheResponseInfo(AppCacheStorage* storage,
+                                           const GURL& manifest_url,
+                                           int64_t response_id,
+                                           net::HttpResponseInfo* http_info,
+                                           int64_t response_data_size)
+    : manifest_url_(manifest_url),
+      response_id_(response_id),
+      http_response_info_(http_info),
+      response_data_size_(response_data_size),
       storage_(storage) {
   DCHECK(http_info);
   DCHECK(response_id != kAppCacheNoResponseId);
   storage_->working_set()->AddResponseInfo(this);
 }
 
 AppCacheResponseInfo::~AppCacheResponseInfo() {
   storage_->working_set()->RemoveResponseInfo(this);
 }
 
 // HttpResponseInfoIOBuffer ------------------------------------------
 
 HttpResponseInfoIOBuffer::HttpResponseInfoIOBuffer()
     : response_data_size(kUnkownResponseDataSize) {}
 
 HttpResponseInfoIOBuffer::HttpResponseInfoIOBuffer(net::HttpResponseInfo* info)
     : http_info(info), response_data_size(kUnkownResponseDataSize) {}
 
 HttpResponseInfoIOBuffer::~HttpResponseInfoIOBuffer() {}
 
 // AppCacheResponseIO ----------------------------------------------
 
-AppCacheResponseIO::AppCacheResponseIO(
-    int64 response_id, int64 group_id, AppCacheDiskCacheInterface* disk_cache)
+AppCacheResponseIO::AppCacheResponseIO(int64_t response_id,
+                                       int64_t group_id,
+                                       AppCacheDiskCacheInterface* disk_cache)
     : response_id_(response_id),
       group_id_(group_id),
       disk_cache_(disk_cache),
       entry_(NULL),
       buffer_len_(0),
-      weak_factory_(this) {
-}
+      weak_factory_(this) {}
 
 AppCacheResponseIO::~AppCacheResponseIO() {
   if (entry_)
     entry_->Close();
 }
 
 void AppCacheResponseIO::ScheduleIOCompletionCallback(int result) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&AppCacheResponseIO::OnIOComplete,
                             weak_factory_.GetWeakPtr(), result));
@@ skipping 66 matching lines @@
     }
     open_callback_.Reset();
   }
   OnOpenEntryComplete();
 }
 
 
 // AppCacheResponseReader ----------------------------------------------
 
 AppCacheResponseReader::AppCacheResponseReader(
-    int64 response_id,
-    int64 group_id,
+    int64_t response_id,
+    int64_t group_id,
     AppCacheDiskCacheInterface* disk_cache)
     : AppCacheResponseIO(response_id, group_id, disk_cache),
       range_offset_(0),
-      range_length_(kint32max),
+      range_length_(std::numeric_limits<int32_t>::max()),
       read_position_(0),
       reading_metadata_size_(0),
-      weak_factory_(this) {
-}
+      weak_factory_(this) {}
 
 AppCacheResponseReader::~AppCacheResponseReader() {
 }
 
 void AppCacheResponseReader::ReadInfo(HttpResponseInfoIOBuffer* info_buf,
                                       const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   DCHECK(!IsReadPending());
   DCHECK(info_buf);
   DCHECK(!info_buf->http_info.get());
@@ skipping 66 matching lines @@
         return;
       }
       DCHECK(!response_truncated);
       info_buffer_->http_info.reset(info.release());
 
       // Also return the size of the response body
       DCHECK(entry_);
       info_buffer_->response_data_size =
           entry_->GetSize(kResponseContentIndex);
 
-      int64 metadata_size = entry_->GetSize(kResponseMetadataIndex);
+      int64_t metadata_size = entry_->GetSize(kResponseMetadataIndex);
       if (metadata_size > 0) {
         reading_metadata_size_ = metadata_size;
         info_buffer_->http_info->metadata = new net::IOBufferWithSize(
             base::CheckedNumeric<size_t>(metadata_size).ValueOrDie());
         ReadRaw(kResponseMetadataIndex, 0,
                 info_buffer_->http_info->metadata.get(), metadata_size);
         return;
       }
     } else {
       read_position_ += result;
     }
   }
   InvokeUserCompletionCallback(result);
 }
 
 void AppCacheResponseReader::OnOpenEntryComplete() {
   if (!entry_)  {
     ScheduleIOCompletionCallback(net::ERR_CACHE_MISS);
     return;
   }
   if (info_buffer_.get())
     ContinueReadInfo();
   else
     ContinueReadData();
 }
 
 // AppCacheResponseWriter ----------------------------------------------
 
 AppCacheResponseWriter::AppCacheResponseWriter(
-    int64 response_id, int64 group_id, AppCacheDiskCacheInterface* disk_cache)
+    int64_t response_id,
+    int64_t group_id,
+    AppCacheDiskCacheInterface* disk_cache)
     : AppCacheResponseIO(response_id, group_id, disk_cache),
       info_size_(0),
       write_position_(0),
       write_amount_(0),
       creation_phase_(INITIAL_ATTEMPT),
-      weak_factory_(this) {
-}
+      weak_factory_(this) {}
 
 AppCacheResponseWriter::~AppCacheResponseWriter() {
 }
 
 void AppCacheResponseWriter::WriteInfo(
     HttpResponseInfoIOBuffer* info_buf,
     const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   DCHECK(!IsWritePending());
   DCHECK(info_buf);
@@ skipping 113 matching lines @@
 
   if (info_buffer_.get())
     ContinueWriteInfo();
   else
     ContinueWriteData();
 }
 
 // AppCacheResponseMetadataWriter ----------------------------------------------
 
 AppCacheResponseMetadataWriter::AppCacheResponseMetadataWriter(
-    int64 response_id,
-    int64 group_id,
+    int64_t response_id,
+    int64_t group_id,
     AppCacheDiskCacheInterface* disk_cache)
     : AppCacheResponseIO(response_id, group_id, disk_cache),
       write_amount_(0),
-      weak_factory_(this) {
-}
+      weak_factory_(this) {}
 
 AppCacheResponseMetadataWriter::~AppCacheResponseMetadataWriter() {
 }
 
 void AppCacheResponseMetadataWriter::WriteMetadata(
     net::IOBuffer* buf,
     int buf_len,
     const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   DCHECK(!IsIOPending());
@@ skipping 14 matching lines @@
   }
   WriteRaw(kResponseMetadataIndex, 0, buffer_.get(), write_amount_);
 }
 
 void AppCacheResponseMetadataWriter::OnIOComplete(int result) {
   DCHECK(result < 0 || write_amount_ == result);
   InvokeUserCompletionCallback(result);
 }
 
 }  // namespace content