Remove kuint64max.

content/browser/fileapi/upload_file_system_file_element_reader_unittest.cc

 // Copyright 2013 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/fileapi/upload_file_system_file_element_reader.h"
 
+#include <limits>
+
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "content/public/test/async_file_test_helper.h"
 #include "content/public/test/test_file_system_context.h"
 #include "net/base/io_buffer.h"
 #include "net/base/test_completion_callback.h"
 #include "storage/browser/fileapi/file_system_backend.h"
 #include "storage/browser/fileapi/file_system_context.h"
 #include "storage/browser/fileapi/file_system_operation_context.h"
@@ skipping 36 matching lines @@
 
     // Prepare a file on file system.
     const char kTestData[] = "abcdefghijklmnop0123456789";
     file_data_.assign(kTestData, kTestData + arraysize(kTestData) - 1);
     const char kFilename[] = "File.dat";
     file_url_ = GetFileSystemURL(kFilename);
     WriteFileSystemFile(kFilename, &file_data_[0], file_data_.size(),
                         &file_modification_time_);
 
     // Create and initialize a reader.
-    reader_.reset(
-        new UploadFileSystemFileElementReader(file_system_context_.get(),
-                                              file_url_,
-                                              0,
-                                              kuint64max,
-                                              file_modification_time_));
+    reader_.reset(new UploadFileSystemFileElementReader(
+        file_system_context_.get(), file_url_, 0,
+        std::numeric_limits<uint64_t>::max(), file_modification_time_));
     net::TestCompletionCallback callback;
     ASSERT_EQ(net::ERR_IO_PENDING, reader_->Init(callback.callback()));
     EXPECT_EQ(net::OK, callback.WaitForResult());
     EXPECT_EQ(file_data_.size(), reader_->GetContentLength());
     EXPECT_EQ(file_data_.size(), reader_->BytesRemaining());
     EXPECT_FALSE(reader_->IsInMemory());
   }
 
   void TearDown() override {
     reader_.reset();
@@ skipping 158 matching lines @@
 }
 
 TEST_F(UploadFileSystemFileElementReaderTest, Range) {
   const int kOffset = 2;
   const int kLength = file_data_.size() - kOffset * 3;
   reader_.reset(new UploadFileSystemFileElementReader(
       file_system_context_.get(), file_url_, kOffset, kLength, base::Time()));
   net::TestCompletionCallback init_callback;
   ASSERT_EQ(net::ERR_IO_PENDING, reader_->Init(init_callback.callback()));
   EXPECT_EQ(net::OK, init_callback.WaitForResult());
-  EXPECT_EQ(static_cast<uint64>(kLength), reader_->GetContentLength());
-  EXPECT_EQ(static_cast<uint64>(kLength), reader_->BytesRemaining());
+  EXPECT_EQ(static_cast<uint64_t>(kLength), reader_->GetContentLength());
+  EXPECT_EQ(static_cast<uint64_t>(kLength), reader_->BytesRemaining());
   scoped_refptr<net::IOBufferWithSize> buf = new net::IOBufferWithSize(kLength);
   net::TestCompletionCallback read_callback;
   ASSERT_EQ(net::ERR_IO_PENDING,
             reader_->Read(buf.get(), buf->size(), read_callback.callback()));
   EXPECT_EQ(kLength, read_callback.WaitForResult());
   EXPECT_TRUE(std::equal(file_data_.begin() + kOffset,
                          file_data_.begin() + kOffset + kLength,
                          buf->data()));
 }
 
 TEST_F(UploadFileSystemFileElementReaderTest, FileChanged) {
   // Expect one second before the actual modification time to simulate change.
   const base::Time expected_modification_time =
       file_modification_time_ - base::TimeDelta::FromSeconds(1);
-  reader_.reset(
-      new UploadFileSystemFileElementReader(file_system_context_.get(),
-                                            file_url_,
-                                            0,
-                                            kuint64max,
-                                            expected_modification_time));
+  reader_.reset(new UploadFileSystemFileElementReader(
+      file_system_context_.get(), file_url_, 0,
+      std::numeric_limits<uint64_t>::max(), expected_modification_time));
   net::TestCompletionCallback init_callback;
   ASSERT_EQ(net::ERR_IO_PENDING, reader_->Init(init_callback.callback()));
   EXPECT_EQ(net::ERR_UPLOAD_FILE_CHANGED, init_callback.WaitForResult());
 }
 
 TEST_F(UploadFileSystemFileElementReaderTest, WrongURL) {
   const GURL wrong_url = GetFileSystemURL("wrong_file_name.dat");
   reader_.reset(new UploadFileSystemFileElementReader(
-      file_system_context_.get(), wrong_url, 0, kuint64max, base::Time()));
+      file_system_context_.get(), wrong_url, 0,
+      std::numeric_limits<uint64_t>::max(), base::Time()));
   net::TestCompletionCallback init_callback;
   ASSERT_EQ(net::ERR_IO_PENDING, reader_->Init(init_callback.callback()));
   EXPECT_EQ(net::ERR_FILE_NOT_FOUND, init_callback.WaitForResult());
 }
 
 }  // namespace content