Switch to standard integer types in google_apis/.

google_apis/drive/drive_api_requests_unittest.cc

 // Copyright (c) 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 <stddef.h>
+#include <stdint.h>
+
 #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/json/json_reader.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
@@ skipping 70 matching lines @@
     return true;
   }
   void NotifyError(DriveApiErrorCode code) override { callback_.Run(); }
   void NotifyResult(DriveApiErrorCode code,
                     const std::string& body,
                     const base::Closure& closure) override {
     callback_.Run();
     closure.Run();
   }
   void NotifyUploadProgress(const net::URLFetcher* source,
-                            int64 current,
-                            int64 total) override {
+                            int64_t current,
+                            int64_t total) override {
     progress_values_.push_back(current);
   }
-  const std::vector<int64>& progress_values() const { return progress_values_; }
+  const std::vector<int64_t>& progress_values() const {
+    return progress_values_;
+  }
 
  private:
   GURL url_;
   std::string content_type_;
   std::string content_data_;
   base::Closure callback_;
-  std::vector<int64> progress_values_;
+  std::vector<int64_t> progress_values_;
 };
 
 void EmptyPreapreCallback(DriveApiErrorCode) {
 }
 void EmptyClosure() {
 }
 
 }  // namespace
 
 class DriveApiRequestsTest : public testing::Test {
@@ skipping 235 matching lines @@
 
     http_request_ = request;
 
     if (!request.content.empty()) {
       auto iter = request.headers.find("Content-Range");
       if (iter == request.headers.end()) {
         // The range must be set.
         return scoped_ptr<net::test_server::HttpResponse>();
       }
 
-      int64 length = 0;
-      int64 start_position = 0;
-      int64 end_position = 0;
+      int64_t length = 0;
+      int64_t start_position = 0;
+      int64_t end_position = 0;
       if (!test_util::ParseContentRangeHeader(
               iter->second, &start_position, &end_position, &length)) {
         // Invalid "Content-Range" value.
         return scoped_ptr<net::test_server::HttpResponse>();
       }
 
       EXPECT_EQ(start_position, received_bytes_);
       EXPECT_EQ(length, content_length_);
 
       // end_position is inclusive, but so +1 to change the range to byte size.
@@ skipping 106 matching lines @@
         "Content-Type: application/json; charset=UTF-8\r\n"
         "\r\n"
         "{\"error\":{\"errors\": ["
         " {\"reason\": \"userRateLimitExceeded\"}]}}\r\n"
         "\r\n"
         "--BOUNDARY--\r\n");
     return response.Pass();
   }
 
   // These are for the current upload file status.
-  int64 received_bytes_;
-  int64 content_length_;
+  int64_t received_bytes_;
+  int64_t content_length_;
 };
 
 TEST_F(DriveApiRequestsTest, DriveApiDataRequest_Fields) {
   // Make sure that "fields" query param is supported by using its subclass,
   // AboutGetRequest.
 
   // Set an expected data file containing valid result.
   expected_data_file_path_ = test_util::GetTestFilePath(
       "drive/about.json");
 
@@ skipping 863 matching lines @@
       // The start and end positions should be set to -1, if an upload is
       // complete.
       EXPECT_EQ(-1, response.start_position_received);
       EXPECT_EQ(-1, response.end_position_received);
       break;
     }
 
     // Check the response.
     EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code);
     EXPECT_EQ(0, response.start_position_received);
-    EXPECT_EQ(static_cast<int64>(end_position), response.end_position_received);
+    EXPECT_EQ(static_cast<int64_t>(end_position),
+              response.end_position_received);
 
     // Check the response by GetUploadStatusRequest.
     {
       base::RunLoop run_loop;
       drive::GetUploadStatusRequest* get_upload_status_request =
           new drive::GetUploadStatusRequest(
               request_sender_.get(),
               upload_url,
               kTestContent.size(),
               test_util::CreateQuitCallback(
                   &run_loop,
                   test_util::CreateCopyResultCallback(&response, &new_entry)));
       request_sender_->StartRequestWithAuthRetry(get_upload_status_request);
       run_loop.Run();
     }
 
     // METHOD_PUT should be used to upload data.
     EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
     // Request should go to the upload URL.
     EXPECT_EQ(upload_url.path(), http_request_.relative_url);
     // Content-Range header should be added.
     EXPECT_EQ("bytes */" + base::SizeTToString(kTestContent.size()),
               http_request_.headers["Content-Range"]);
     EXPECT_TRUE(http_request_.has_content);
     EXPECT_TRUE(http_request_.content.empty());
 
     // Check the response.
     EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code);
     EXPECT_EQ(0, response.start_position_received);
-    EXPECT_EQ(static_cast<int64>(end_position),
+    EXPECT_EQ(static_cast<int64_t>(end_position),
               response.end_position_received);
   }
 }
 
 TEST_F(DriveApiRequestsTest, UploadNewFileWithMetadataRequest) {
   const base::Time::Exploded kModifiedDate = {2012, 7, 0, 19, 15, 59, 13, 123};
   const base::Time::Exploded kLastViewedByMeDate =
       {2013, 7, 0, 19, 15, 59, 13, 123};
 
   // Set an expected url for uploading.
@@ skipping 865 matching lines @@
                                     "Header: value\r\n"
                                     "\r\n"
                                     "BODY\r\n"
                                     "--BOUNDARY-- \t",
                                     &parts));
   ASSERT_EQ(1u, parts.size());
   EXPECT_EQ(HTTP_SUCCESS, parts[0].code);
   EXPECT_EQ("BODY", parts[0].body);
 }
 }  // namespace google_apis