Remove kuint64max.

net/url_request/url_fetcher_impl_unittest.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/url_request/url_fetcher_impl.h"
 
 #include <stdint.h>
 #include <string.h>
 
 #include <algorithm>
+#include <limits>
 #include <string>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/path_service.h"
@@ skipping 90 matching lines @@
   // URLFetcherDelegate:
   void OnURLFetchComplete(const URLFetcher* source) override {
     EXPECT_FALSE(did_complete_);
     EXPECT_TRUE(fetcher_);
     EXPECT_EQ(fetcher_.get(), source);
     did_complete_ = true;
     run_loop_.Quit();
   }
 
   void OnURLFetchDownloadProgress(const URLFetcher* source,
-                                  int64 current,
-                                  int64 total) override {
+                                  int64_t current,
+                                  int64_t total) override {
     // Note that the current progress may be greater than the previous progress,
     // in the case of retrying the request.
     EXPECT_FALSE(did_complete_);
     EXPECT_TRUE(fetcher_);
     EXPECT_EQ(source, fetcher_.get());
 
     EXPECT_LE(0, current);
     // If file size is not known, |total| is -1.
     if (total >= 0)
       EXPECT_LE(current, total);
   }
 
   void OnURLFetchUploadProgress(const URLFetcher* source,
-                                int64 current,
-                                int64 total) override {
+                                int64_t current,
+                                int64_t total) override {
     // Note that the current progress may be greater than the previous progress,
     // in the case of retrying the request.
     EXPECT_FALSE(did_complete_);
     EXPECT_TRUE(fetcher_);
     EXPECT_EQ(source, fetcher_.get());
 
     EXPECT_LE(0, current);
     // If file size is not known, |total| is -1.
     if (total >= 0)
       EXPECT_LE(current, total);
@@ skipping 545 matching lines @@
   EXPECT_EQ(kUploadData, data);
 }
 
 TEST_F(URLFetcherTest, PostEntireFile) {
   base::FilePath upload_path = GetUploadFileTestPath();
 
   WaitingURLFetcherDelegate delegate;
   delegate.CreateFetcher(test_server_->GetURL("/echo"), URLFetcher::POST,
                          CreateSameThreadContextGetter());
   delegate.fetcher()->SetUploadFilePath("application/x-www-form-urlencoded",
-                                        upload_path, 0, kuint64max,
+                                        upload_path, 0,
+                                        std::numeric_limits<uint64_t>::max(),
                                         base::ThreadTaskRunnerHandle::Get());
   delegate.StartFetcherAndWait();
 
   EXPECT_TRUE(delegate.fetcher()->GetStatus().is_success());
   EXPECT_EQ(200, delegate.fetcher()->GetResponseCode());
 
   std::string expected;
   ASSERT_TRUE(base::ReadFileToString(upload_path, &expected));
   std::string data;
   ASSERT_TRUE(delegate.fetcher()->GetResponseAsString(&data));
@@ skipping 62 matching lines @@
 // Checks that upload progress increases over time, never exceeds what's already
 // been sent, and adds a chunk whenever all previously appended chunks have
 // been uploaded.
 class CheckUploadProgressDelegate : public WaitingURLFetcherDelegate {
  public:
   CheckUploadProgressDelegate()
       : chunk_(1 << 16, 'a'), num_chunks_appended_(0), last_seen_progress_(0) {}
   ~CheckUploadProgressDelegate() override {}
 
   void OnURLFetchUploadProgress(const URLFetcher* source,
-                                int64 current,
-                                int64 total) override {
+                                int64_t current,
+                                int64_t total) override {
     // Run default checks.
     WaitingURLFetcherDelegate::OnURLFetchUploadProgress(source, current, total);
 
     EXPECT_LE(last_seen_progress_, current);
     EXPECT_LE(current, bytes_appended());
     last_seen_progress_ = current;
     MaybeAppendChunk();
   }
 
   // Append the next chunk if all previously appended chunks have been sent.
   void MaybeAppendChunk() {
     const int kNumChunks = 5;
     if (last_seen_progress_ == bytes_appended() &&
         num_chunks_appended_ < kNumChunks) {
       ++num_chunks_appended_;
       fetcher()->AppendChunkToUpload(chunk_,
                                      num_chunks_appended_ == kNumChunks);
     }
   }
 
  private:
-  int64 bytes_appended() const { return num_chunks_appended_ * chunk_.size(); }
+  int64_t bytes_appended() const {
+    return num_chunks_appended_ * chunk_.size();
+  }
 
   const std::string chunk_;
 
-  int64 num_chunks_appended_;
-  int64 last_seen_progress_;
+  int64_t num_chunks_appended_;
+  int64_t last_seen_progress_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckUploadProgressDelegate);
 };
 
 TEST_F(URLFetcherTest, UploadProgress) {
   CheckUploadProgressDelegate delegate;
   delegate.CreateFetcher(test_server_->GetURL("/echo"), URLFetcher::POST,
                          CreateSameThreadContextGetter());
   // Use a chunked upload so that the upload can be paused after uploading data.
   // Since upload progress uses a timer, the delegate may not receive any
@@ skipping 11 matching lines @@
 
   EXPECT_TRUE(delegate.fetcher()->GetStatus().is_success());
   EXPECT_EQ(200, delegate.fetcher()->GetResponseCode());
   EXPECT_TRUE(delegate.did_complete());
 }
 
 // Checks that download progress never decreases, never exceeds file size, and
 // that file size is correctly reported.
 class CheckDownloadProgressDelegate : public WaitingURLFetcherDelegate {
  public:
-  CheckDownloadProgressDelegate(int64 file_size)
+  CheckDownloadProgressDelegate(int64_t file_size)
       : file_size_(file_size), last_seen_progress_(0) {}
   ~CheckDownloadProgressDelegate() override {}
 
   void OnURLFetchDownloadProgress(const URLFetcher* source,
-                                  int64 current,
-                                  int64 total) override {
+                                  int64_t current,
+                                  int64_t total) override {
     // Run default checks.
     WaitingURLFetcherDelegate::OnURLFetchDownloadProgress(source, current,
                                                           total);
 
     EXPECT_LE(last_seen_progress_, current);
     EXPECT_EQ(file_size_, total);
     last_seen_progress_ = current;
   }
 
  private:
-  int64 file_size_;
-  int64 last_seen_progress_;
+  int64_t file_size_;
+  int64_t last_seen_progress_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckDownloadProgressDelegate);
 };
 
 TEST_F(URLFetcherTest, DownloadProgress) {
   // Get a file large enough to require more than one read into
   // URLFetcher::Core's IOBuffer.
   const char kFileToFetch[] = "animate1.gif";
 
   std::string file_contents;
@@ skipping 16 matching lines @@
   ASSERT_TRUE(delegate.fetcher()->GetResponseAsString(&data));
   EXPECT_EQ(file_contents, data);
 }
 
 class CancelOnUploadProgressDelegate : public WaitingURLFetcherDelegate {
  public:
   CancelOnUploadProgressDelegate() {}
   ~CancelOnUploadProgressDelegate() override {}
 
   void OnURLFetchUploadProgress(const URLFetcher* source,
-                                int64 current,
-                                int64 total) override {
+                                int64_t current,
+                                int64_t total) override {
     CancelFetch();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CancelOnUploadProgressDelegate);
 };
 
 // Check that a fetch can be safely cancelled/deleted during an upload progress
 // callback.
 TEST_F(URLFetcherTest, CancelInUploadProgressCallback) {
@@ skipping 15 matching lines @@
   EXPECT_FALSE(delegate.did_complete());
   EXPECT_FALSE(delegate.fetcher());
 }
 
 class CancelOnDownloadProgressDelegate : public WaitingURLFetcherDelegate {
  public:
   CancelOnDownloadProgressDelegate() {}
   ~CancelOnDownloadProgressDelegate() override {}
 
   void OnURLFetchDownloadProgress(const URLFetcher* source,
-                                  int64 current,
-                                  int64 total) override {
+                                  int64_t current,
+                                  int64_t total) override {
     CancelFetch();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CancelOnDownloadProgressDelegate);
 };
 
 // Check that a fetch can be safely cancelled/deleted during a download progress
 // callback.
 TEST_F(URLFetcherTest, CancelInDownloadProgressCallback) {
@@ skipping 473 matching lines @@
   EXPECT_EQ(-1, delegate.fetcher()->GetResponseCode());
   EXPECT_TRUE(delegate.fetcher()->GetCookies().empty());
   std::string data;
   EXPECT_TRUE(delegate.fetcher()->GetResponseAsString(&data));
   EXPECT_TRUE(data.empty());
 }
 
 }  // namespace
 
 }  // namespace net