Add ProgressCallback to DriveServiceInterface::DownloadFile.

chrome/browser/google_apis/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 "chrome/browser/google_apis/drive_uploader.h"
 
 #include <algorithm>
 #include <cstdlib>
 #include <string>
 #include <utility>
@@ skipping 34 matching lines @@
                                std::string* data) {
   data->resize(size);
   for (size_t i = 0; i < size; ++i)
     (*data)[i] = static_cast<char>(rand() % 256);  // NOLINT
   if (!file_util::CreateTemporaryFileInDir(temp_dir, path))
     return false;
   return file_util::WriteFile(*path, data->c_str(), static_cast<int>(size)) ==
       static_cast<int>(size);
 }
 
-typedef std::pair<int64, int64> ProgressInfo;
-
-void AppendProgressCallbackResult(std::vector<ProgressInfo>* progress_values,
-                                  int64 progress,
-                                  int64 total) {
-  progress_values->push_back(ProgressInfo(progress, total));
-}
-
 // 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.
   explicit MockDriveServiceWithUploadExpectation(
       const std::string& expected_upload_content)
      : expected_upload_content_(expected_upload_content),
        received_bytes_(0),
@@ skipping 235 matching lines @@
   ASSERT_TRUE(CreateFileOfSpecifiedSize(temp_dir_.path(), 0,
                                         &local_path, &data));
 
   DriveUploadError error = DRIVE_UPLOAD_ERROR_ABORT;
   base::FilePath drive_path;
   base::FilePath file_path;
   scoped_ptr<ResourceEntry> resource_entry;
 
   MockDriveServiceWithUploadExpectation mock_service(data);
   DriveUploader uploader(&mock_service);
-  std::vector<ProgressInfo> upload_progress_values;
+  std::vector<test_util::ProgressInfo> upload_progress_values;
   uploader.UploadExistingFile(
       kTestInitiateUploadResourceId,
       base::FilePath::FromUTF8Unsafe(kTestDrivePath),
       local_path,
       kTestMimeType,
       std::string(),  // etag
       test_util::CreateCopyResultCallback(
           &error, &drive_path, &file_path, &resource_entry),
-      base::Bind(&AppendProgressCallbackResult, &upload_progress_values));
+      base::Bind(&test_util::AppendProgressCallbackResult,
+                 &upload_progress_values));
   test_util::RunBlockingPoolTask();
 
   EXPECT_EQ(1, mock_service.resume_upload_call_count());
   EXPECT_EQ(0, mock_service.received_bytes());
   EXPECT_EQ(DRIVE_UPLOAD_OK, error);
   EXPECT_EQ(base::FilePath::FromUTF8Unsafe(kTestDrivePath), drive_path);
   EXPECT_EQ(local_path, file_path);
   ASSERT_TRUE(resource_entry);
   EXPECT_EQ(kTestDummyId, resource_entry->id());
   ASSERT_EQ(1U, upload_progress_values.size());
-  EXPECT_EQ(ProgressInfo(0, 0), upload_progress_values[0]);
+  EXPECT_EQ(test_util::ProgressInfo(0, 0), upload_progress_values[0]);
 }
 
 TEST_F(DriveUploaderTest, UploadExisting512KB) {
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(CreateFileOfSpecifiedSize(temp_dir_.path(), 512 * 1024,
                                         &local_path, &data));
 
   DriveUploadError error = DRIVE_UPLOAD_ERROR_ABORT;
   base::FilePath drive_path;
   base::FilePath file_path;
   scoped_ptr<ResourceEntry> resource_entry;
 
   MockDriveServiceWithUploadExpectation mock_service(data);
   DriveUploader uploader(&mock_service);
-  std::vector<ProgressInfo> upload_progress_values;
+  std::vector<test_util::ProgressInfo> upload_progress_values;
   uploader.UploadExistingFile(
       kTestInitiateUploadResourceId,
       base::FilePath::FromUTF8Unsafe(kTestDrivePath),
       local_path,
       kTestMimeType,
       std::string(),  // etag
       test_util::CreateCopyResultCallback(
           &error, &drive_path, &file_path, &resource_entry),
-      base::Bind(&AppendProgressCallbackResult, &upload_progress_values));
+      base::Bind(&test_util::AppendProgressCallbackResult,
+                 &upload_progress_values));
   test_util::RunBlockingPoolTask();
 
   // 512KB upload should not be split into multiple chunks.
   EXPECT_EQ(1, mock_service.resume_upload_call_count());
   EXPECT_EQ(512 * 1024, mock_service.received_bytes());
   EXPECT_EQ(DRIVE_UPLOAD_OK, error);
   EXPECT_EQ(base::FilePath::FromUTF8Unsafe(kTestDrivePath), drive_path);
   EXPECT_EQ(local_path, file_path);
   ASSERT_TRUE(resource_entry);
   EXPECT_EQ(kTestDummyId, resource_entry->id());
   ASSERT_EQ(1U, upload_progress_values.size());
-  EXPECT_EQ(ProgressInfo(512 * 1024, 512 * 1024), upload_progress_values[0]);
+  EXPECT_EQ(test_util::ProgressInfo(512 * 1024, 512 * 1024),
+            upload_progress_values[0]);
 }
 
 TEST_F(DriveUploaderTest, UploadExisting1234KB) {
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(CreateFileOfSpecifiedSize(temp_dir_.path(), 1234 * 1024,
                                         &local_path, &data));
 
   DriveUploadError error = DRIVE_UPLOAD_ERROR_ABORT;
   base::FilePath drive_path;
   base::FilePath file_path;
   scoped_ptr<ResourceEntry> resource_entry;
 
   MockDriveServiceWithUploadExpectation mock_service(data);
   DriveUploader uploader(&mock_service);
-  std::vector<ProgressInfo> upload_progress_values;
+  std::vector<test_util::ProgressInfo> upload_progress_values;
   uploader.UploadExistingFile(
       kTestInitiateUploadResourceId,
       base::FilePath::FromUTF8Unsafe(kTestDrivePath),
       local_path,
       kTestMimeType,
       std::string(),  // etag
       test_util::CreateCopyResultCallback(
           &error, &drive_path, &file_path, &resource_entry),
-      base::Bind(&AppendProgressCallbackResult, &upload_progress_values));
+      base::Bind(&test_util::AppendProgressCallbackResult,
+                 &upload_progress_values));
   test_util::RunBlockingPoolTask();
 
   // The file should be split into 3 chunks (1234 = 512 + 512 + 210).
   EXPECT_EQ(3, mock_service.resume_upload_call_count());
   EXPECT_EQ(1234 * 1024, mock_service.received_bytes());
   EXPECT_EQ(DRIVE_UPLOAD_OK, error);
   EXPECT_EQ(base::FilePath::FromUTF8Unsafe(kTestDrivePath), drive_path);
   EXPECT_EQ(local_path, file_path);
   ASSERT_TRUE(resource_entry);
   EXPECT_EQ(kTestDummyId, resource_entry->id());
   // It is the duty of DriveUploader to accumulate up the progress value.
   ASSERT_EQ(3U, upload_progress_values.size());
-  EXPECT_EQ(ProgressInfo(512 * 1024, 1234 * 1024), upload_progress_values[0]);
-  EXPECT_EQ(ProgressInfo(1024 * 1024, 1234 * 1024), upload_progress_values[1]);
-  EXPECT_EQ(ProgressInfo(1234 * 1024, 1234 * 1024), upload_progress_values[2]);
+  EXPECT_EQ(test_util::ProgressInfo(512 * 1024, 1234 * 1024),
+            upload_progress_values[0]);
+  EXPECT_EQ(test_util::ProgressInfo(1024 * 1024, 1234 * 1024),
+            upload_progress_values[1]);
+  EXPECT_EQ(test_util::ProgressInfo(1234 * 1024, 1234 * 1024),
+            upload_progress_values[2]);
 }
 
 TEST_F(DriveUploaderTest, UploadNew1234KB) {
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(CreateFileOfSpecifiedSize(temp_dir_.path(), 1234 * 1024,
                                         &local_path, &data));
 
   DriveUploadError error = DRIVE_UPLOAD_ERROR_ABORT;
   base::FilePath drive_path;
@@ skipping 148 matching lines @@
       test_util::CreateCopyResultCallback(
           &error, &drive_path, &file_path, &resource_entry),
       google_apis::ProgressCallback());
   test_util::RunBlockingPoolTask();
 
   // Should return failure without doing any attempt to connect to the server.
   EXPECT_EQ(DRIVE_UPLOAD_ERROR_NOT_FOUND, error);
 }
 
 }  // namespace google_apis