Switch to standard integer types in components/, part 1 of 4.

components/drive/drive_uploader_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 "components/drive/drive_uploader.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 25 matching lines @@
 namespace {
 
 const char kTestDummyMd5[] = "dummy_md5";
 const char kTestDocumentTitle[] = "Hello world";
 const char kTestInitiateUploadParentResourceId[] = "parent_resource_id";
 const char kTestInitiateUploadResourceId[] = "resource_id";
 const char kTestMimeType[] = "text/plain";
 const char kTestUploadNewFileURL[] = "http://test/upload_location/new_file";
 const char kTestUploadExistingFileURL[] =
     "http://test/upload_location/existing_file";
-const int64 kUploadChunkSize = 1024 * 1024 * 1024;
+const int64_t kUploadChunkSize = 1024 * 1024 * 1024;
 const char kTestETag[] = "test_etag";
 
 CancelCallback SendMultipartUploadResult(
     DriveApiErrorCode response_code,
-    int64 content_length,
+    int64_t content_length,
     const google_apis::FileResourceCallback& callback,
     const google_apis::ProgressCallback& progress_callback) {
   // Callback progress
   if (!progress_callback.is_null()) {
     // For the testing purpose, it always notifies the progress at the end of
     // whole file uploading.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(progress_callback, content_length, content_length));
   }
 
   // MultipartUploadXXXFile is an asynchronous function, so don't callback
   // directly.
   scoped_ptr<FileResource> entry;
   entry.reset(new FileResource);
   entry->set_md5_checksum(kTestDummyMd5);
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(callback, response_code, base::Passed(&entry)));
   return CancelCallback();
 }
 
 // Mock DriveService that verifies if the uploaded content matches the preset
 // expectation.
 class MockDriveServiceWithUploadExpectation : public DummyDriveService {
  public:
   // Sets up an expected upload content. InitiateUpload and ResumeUpload will
   // verify that the specified data is correctly uploaded.
   MockDriveServiceWithUploadExpectation(
       const base::FilePath& expected_upload_file,
-      int64 expected_content_length)
+      int64_t expected_content_length)
       : expected_upload_file_(expected_upload_file),
         expected_content_length_(expected_content_length),
         received_bytes_(0),
         resume_upload_call_count_(0),
         multipart_upload_call_count_(0) {}
 
-  int64 received_bytes() const { return received_bytes_; }
-  void set_received_bytes(int64 received_bytes) {
+  int64_t received_bytes() const { return received_bytes_; }
+  void set_received_bytes(int64_t received_bytes) {
     received_bytes_ = received_bytes;
   }
 
-  int64 resume_upload_call_count() const { return resume_upload_call_count_; }
-  int64 multipart_upload_call_count() const {
+  int64_t resume_upload_call_count() const { return resume_upload_call_count_; }
+  int64_t multipart_upload_call_count() const {
     return multipart_upload_call_count_;
   }
 
  private:
   // DriveServiceInterface overrides.
   // Handles a request for obtaining an upload location URL.
   CancelCallback InitiateUploadNewFile(
       const std::string& content_type,
-      int64 content_length,
+      int64_t content_length,
       const std::string& parent_resource_id,
       const std::string& title,
       const UploadNewFileOptions& options,
       const InitiateUploadCallback& callback) override {
     EXPECT_EQ(kTestDocumentTitle, title);
     EXPECT_EQ(kTestMimeType, content_type);
     EXPECT_EQ(expected_content_length_, content_length);
     EXPECT_EQ(kTestInitiateUploadParentResourceId, parent_resource_id);
 
     // Calls back the upload URL for subsequent ResumeUpload requests.
     // InitiateUpload is an asynchronous function, so don't callback directly.
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
         base::Bind(callback, HTTP_SUCCESS, GURL(kTestUploadNewFileURL)));
     return CancelCallback();
   }
 
   CancelCallback InitiateUploadExistingFile(
       const std::string& content_type,
-      int64 content_length,
+      int64_t content_length,
       const std::string& resource_id,
       const UploadExistingFileOptions& options,
       const InitiateUploadCallback& callback) override {
     EXPECT_EQ(kTestMimeType, content_type);
     EXPECT_EQ(expected_content_length_, content_length);
     EXPECT_EQ(kTestInitiateUploadResourceId, resource_id);
 
     if (!options.etag.empty() && options.etag != kTestETag) {
       base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
           base::Bind(callback, HTTP_PRECONDITION, GURL()));
       return CancelCallback();
     }
 
     // Calls back the upload URL for subsequent ResumeUpload requests.
     // InitiateUpload is an asynchronous function, so don't callback directly.
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
         base::Bind(callback, HTTP_SUCCESS, GURL(kTestUploadExistingFileURL)));
     return CancelCallback();
   }
 
   // Handles a request for uploading a chunk of bytes.
   CancelCallback ResumeUpload(
       const GURL& upload_location,
-      int64 start_position,
-      int64 end_position,
-      int64 content_length,
+      int64_t start_position,
+      int64_t end_position,
+      int64_t content_length,
       const std::string& content_type,
       const base::FilePath& local_file_path,
       const UploadRangeCallback& callback,
       const ProgressCallback& progress_callback) override {
     // The upload range should start from the current first unreceived byte.
     EXPECT_EQ(received_bytes_, start_position);
     EXPECT_EQ(expected_upload_file_, local_file_path);
 
     // The upload data must be split into 512KB chunks.
-    const int64 expected_chunk_end =
+    const int64_t expected_chunk_end =
         std::min(received_bytes_ + kUploadChunkSize, expected_content_length_);
     EXPECT_EQ(expected_chunk_end, end_position);
 
     // The upload URL returned by InitiateUpload() must be used.
     EXPECT_TRUE(GURL(kTestUploadNewFileURL) == upload_location ||
                 GURL(kTestUploadExistingFileURL) == upload_location);
 
     // Other parameters should be the exact values passed to DriveUploader.
     EXPECT_EQ(expected_content_length_, content_length);
     EXPECT_EQ(kTestMimeType, content_type);
 
     // Update the internal status of the current upload session.
     resume_upload_call_count_++;
     received_bytes_ = end_position;
 
     // Callback progress
     if (!progress_callback.is_null()) {
       // For the testing purpose, it always notifies the progress at the end of
       // each chunk uploading.
-      int64 chunk_size = end_position - start_position;
+      int64_t chunk_size = end_position - start_position;
       base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
           base::Bind(progress_callback, chunk_size, chunk_size));
     }
 
     SendUploadRangeResponse(upload_location, callback);
     return CancelCallback();
   }
 
   // Handles a request to fetch the current upload status.
   CancelCallback GetUploadStatus(const GURL& upload_location,
-                                 int64 content_length,
+                                 int64_t content_length,
                                  const UploadRangeCallback& callback) override {
     EXPECT_EQ(expected_content_length_, content_length);
     // The upload URL returned by InitiateUpload() must be used.
     EXPECT_TRUE(GURL(kTestUploadNewFileURL) == upload_location ||
                 GURL(kTestUploadExistingFileURL) == upload_location);
 
     SendUploadRangeResponse(upload_location, callback);
     return CancelCallback();
   }
 
@@ skipping 15 matching lines @@
       response = UploadRangeResponse(
           HTTP_RESUME_INCOMPLETE, 0, received_bytes_);
     }
     // ResumeUpload is an asynchronous function, so don't callback directly.
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
         base::Bind(callback, response, base::Passed(&entry)));
   }
 
   CancelCallback MultipartUploadNewFile(
       const std::string& content_type,
-      int64 content_length,
+      int64_t content_length,
       const std::string& parent_resource_id,
       const std::string& title,
       const base::FilePath& local_file_path,
       const UploadNewFileOptions& options,
       const google_apis::FileResourceCallback& callback,
       const google_apis::ProgressCallback& progress_callback) override {
     EXPECT_EQ(kTestMimeType, content_type);
     EXPECT_EQ(expected_content_length_, content_length);
     EXPECT_EQ(kTestInitiateUploadParentResourceId, parent_resource_id);
     EXPECT_EQ(kTestDocumentTitle, title);
     EXPECT_EQ(expected_upload_file_, local_file_path);
 
     received_bytes_ = content_length;
     multipart_upload_call_count_++;
     return SendMultipartUploadResult(HTTP_CREATED, content_length, callback,
                                      progress_callback);
   }
 
   CancelCallback MultipartUploadExistingFile(
       const std::string& content_type,
-      int64 content_length,
+      int64_t content_length,
       const std::string& resource_id,
       const base::FilePath& local_file_path,
       const UploadExistingFileOptions& options,
       const google_apis::FileResourceCallback& callback,
       const google_apis::ProgressCallback& progress_callback) override {
     EXPECT_EQ(kTestMimeType, content_type);
     EXPECT_EQ(expected_content_length_, content_length);
     EXPECT_EQ(kTestInitiateUploadResourceId, resource_id);
     EXPECT_EQ(expected_upload_file_, local_file_path);
 
     if (!options.etag.empty() && options.etag != kTestETag) {
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
           base::Bind(callback, HTTP_PRECONDITION,
                      base::Passed(make_scoped_ptr<FileResource>(NULL))));
       return CancelCallback();
     }
 
     received_bytes_ = content_length;
     multipart_upload_call_count_++;
     return SendMultipartUploadResult(HTTP_SUCCESS, content_length, callback,
                                      progress_callback);
   }
 
   const base::FilePath expected_upload_file_;
-  const int64 expected_content_length_;
-  int64 received_bytes_;
-  int64 resume_upload_call_count_;
-  int64 multipart_upload_call_count_;
+  const int64_t expected_content_length_;
+  int64_t received_bytes_;
+  int64_t resume_upload_call_count_;
+  int64_t multipart_upload_call_count_;
 };
 
 // Mock DriveService that returns a failure at InitiateUpload().
 class MockDriveServiceNoConnectionAtInitiate : public DummyDriveService {
   // Returns error.
   CancelCallback InitiateUploadNewFile(
       const std::string& content_type,
-      int64 content_length,
+      int64_t content_length,
       const std::string& parent_resource_id,
       const std::string& title,
       const UploadNewFileOptions& options,
       const InitiateUploadCallback& callback) override {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
         base::Bind(callback, DRIVE_NO_CONNECTION, GURL()));
     return CancelCallback();
   }
 
   CancelCallback InitiateUploadExistingFile(
       const std::string& content_type,
-      int64 content_length,
+      int64_t content_length,
       const std::string& resource_id,
       const UploadExistingFileOptions& options,
       const InitiateUploadCallback& callback) override {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
         base::Bind(callback, DRIVE_NO_CONNECTION, GURL()));
     return CancelCallback();
   }
 
   // Should not be used.
   CancelCallback ResumeUpload(
       const GURL& upload_url,
-      int64 start_position,
-      int64 end_position,
-      int64 content_length,
+      int64_t start_position,
+      int64_t end_position,
+      int64_t content_length,
       const std::string& content_type,
       const base::FilePath& local_file_path,
       const UploadRangeCallback& callback,
       const ProgressCallback& progress_callback) override {
     NOTREACHED();
     return CancelCallback();
   }
 
   CancelCallback MultipartUploadNewFile(
       const std::string& content_type,
-      int64 content_length,
+      int64_t content_length,
       const std::string& parent_resource_id,
       const std::string& title,
       const base::FilePath& local_file_path,
       const UploadNewFileOptions& options,
       const google_apis::FileResourceCallback& callback,
       const google_apis::ProgressCallback& progress_callback) override {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, DRIVE_NO_CONNECTION,
                    base::Passed(make_scoped_ptr<FileResource>(NULL))));
     return CancelCallback();
   }
 
   CancelCallback MultipartUploadExistingFile(
       const std::string& content_type,
-      int64 content_length,
+      int64_t content_length,
       const std::string& resource_id,
       const base::FilePath& local_file_path,
       const UploadExistingFileOptions& options,
       const google_apis::FileResourceCallback& callback,
       const google_apis::ProgressCallback& progress_callback) override {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, DRIVE_NO_CONNECTION,
                    base::Passed(make_scoped_ptr<FileResource>(NULL))));
     return CancelCallback();
   }
 };
 
 // Mock DriveService that returns a failure at ResumeUpload().
 class MockDriveServiceNoConnectionAtResume : public DummyDriveService {
   // Succeeds and returns an upload location URL.
   CancelCallback InitiateUploadNewFile(
       const std::string& content_type,
-      int64 content_length,
+      int64_t content_length,
       const std::string& parent_resource_id,
       const std::string& title,
       const UploadNewFileOptions& options,
       const InitiateUploadCallback& callback) override {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
         base::Bind(callback, HTTP_SUCCESS, GURL(kTestUploadNewFileURL)));
     return CancelCallback();
   }
 
   CancelCallback InitiateUploadExistingFile(
       const std::string& content_type,
-      int64 content_length,
+      int64_t content_length,
       const std::string& resource_id,
       const UploadExistingFileOptions& options,
       const InitiateUploadCallback& callback) override {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
         base::Bind(callback, HTTP_SUCCESS, GURL(kTestUploadExistingFileURL)));
     return CancelCallback();
   }
 
   // Returns error.
   CancelCallback ResumeUpload(
       const GURL& upload_url,
-      int64 start_position,
-      int64 end_position,
-      int64 content_length,
+      int64_t start_position,
+      int64_t end_position,
+      int64_t content_length,
       const std::string& content_type,
       const base::FilePath& local_file_path,
       const UploadRangeCallback& callback,
       const ProgressCallback& progress_callback) override {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
         base::Bind(callback,
                    UploadRangeResponse(DRIVE_NO_CONNECTION, -1, -1),
                    base::Passed(scoped_ptr<FileResource>())));
     return CancelCallback();
   }
 };
 
 // Mock DriveService that returns a failure at GetUploadStatus().
 class MockDriveServiceNoConnectionAtGetUploadStatus : public DummyDriveService {
   // Returns error.
   CancelCallback GetUploadStatus(const GURL& upload_url,
-                                 int64 content_length,
+                                 int64_t content_length,
                                  const UploadRangeCallback& callback) override {
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
         base::Bind(callback,
                    UploadRangeResponse(DRIVE_NO_CONNECTION, -1, -1),
                    base::Passed(scoped_ptr<FileResource>())));
     return CancelCallback();
   }
 };
 
 class DriveUploaderTest : public testing::Test {
@@ skipping 349 matching lines @@
   ASSERT_EQ(1U, upload_progress_values.size());
   EXPECT_EQ(test_util::ProgressInfo(1024 * 1024, 1024 * 1024),
             upload_progress_values[0]);
 }
 
 class MockDriveServiceForBatchProcessing : public DummyDriveService {
  public:
   struct UploadFileInfo {
     enum { NEW_FILE, EXISTING_FILE } type;
     std::string content_type;
-    uint64 content_length;
+    uint64_t content_length;
     std::string parent_resource_id;
     std::string resource_id;
     std::string title;
     base::FilePath local_file_path;
     google_apis::FileResourceCallback callback;
     google_apis::ProgressCallback progress_callback;
   };
 
   class BatchRequestConfigurator : public BatchRequestConfiguratorInterface {
    public:
     explicit BatchRequestConfigurator(
         MockDriveServiceForBatchProcessing* service)
         : service(service) {}
 
     CancelCallback MultipartUploadNewFile(
         const std::string& content_type,
-        int64 content_length,
+        int64_t content_length,
         const std::string& parent_resource_id,
         const std::string& title,
         const base::FilePath& local_file_path,
         const UploadNewFileOptions& options,
         const google_apis::FileResourceCallback& callback,
         const google_apis::ProgressCallback& progress_callback) override {
       UploadFileInfo info;
       info.type = UploadFileInfo::NEW_FILE;
       info.content_type = content_type;
       info.content_length = content_length;
       info.parent_resource_id = parent_resource_id;
       info.title = title;
       info.local_file_path = local_file_path;
       info.callback = callback;
       info.progress_callback = progress_callback;
       service->files.push_back(info);
       return CancelCallback();
     }
 
     CancelCallback MultipartUploadExistingFile(
         const std::string& content_type,
-        int64 content_length,
+        int64_t content_length,
         const std::string& resource_id,
         const base::FilePath& local_file_path,
         const UploadExistingFileOptions& options,
         const google_apis::FileResourceCallback& callback,
         const google_apis::ProgressCallback& progress_callback) override {
       UploadFileInfo info;
       info.type = UploadFileInfo::EXISTING_FILE;
       info.content_type = content_type;
       info.content_length = content_length;
       info.resource_id = resource_id;
@@ skipping 122 matching lines @@
 
   EXPECT_EQ(HTTP_NOT_FOUND, results[0].error);
   EXPECT_TRUE(results[0].resume_url.is_empty());
   EXPECT_FALSE(results[0].file);
 
   EXPECT_EQ(HTTP_NOT_FOUND, results[1].error);
   EXPECT_TRUE(results[1].resume_url.is_empty());
   EXPECT_FALSE(results[1].file);
 }
 }  // namespace drive