Add ProgressCallback to DriveServiceInterface::DownloadFile.

chrome/browser/google_apis/fake_drive_service_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/fake_drive_service.h"
 
 #include <string>
 #include <vector>
 
 #include "base/file_util.h"
@@ skipping 73 matching lines @@
         test_util::CreateCopyResultCallback(&error, &about_resource));
     message_loop_.RunUntilIdle();
     return about_resource->largest_change_id();
   }
 
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   FakeDriveService fake_service_;
 };
 
-void AppendProgressCallbackResult(std::vector<int64>* values,
-                                  int64 progress,
-                                  int64 total) {
-  values->push_back(progress);
-}
-
 TEST_F(FakeDriveServiceTest, GetAllResourceList) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/root_feed.json"));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<ResourceList> resource_list;
   fake_service_.GetAllResourceList(
       test_util::CreateCopyResultCallback(&error, &resource_list));
   message_loop_.RunUntilIdle();
 
@@ skipping 734 matching lines @@
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
 }
 
 TEST_F(FakeDriveServiceTest, DownloadFile_ExistingFile) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/root_feed.json"));
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
+  std::vector<test_util::ProgressInfo> download_progress_values;
+
   const GURL kContentUrl("https://file_content_url/");
   const base::FilePath kOutputFilePath =
       temp_dir.path().AppendASCII("whatever.txt");
   GDataErrorCode error = GDATA_OTHER_ERROR;
   base::FilePath output_file_path;
   fake_service_.DownloadFile(
       base::FilePath::FromUTF8Unsafe("/drive/whatever.txt"),  // virtual path
       kOutputFilePath,
       kContentUrl,
       test_util::CreateCopyResultCallback(&error, &output_file_path),
-      GetContentCallback());
+      GetContentCallback(),
+      base::Bind(&test_util::AppendProgressCallbackResult,
+                 &download_progress_values));
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(output_file_path, kOutputFilePath);
   std::string content;
   ASSERT_TRUE(file_util::ReadFileToString(output_file_path, &content));
   // The content is "x"s of the file size specified in root_feed.json.
   EXPECT_EQ("xxxxxxxxxx", content);
+  ASSERT_TRUE(!download_progress_values.empty());
+  EXPECT_TRUE(base::STLIsSorted(download_progress_values));
+  EXPECT_GE(download_progress_values.front().first, 0);
+  EXPECT_LE(download_progress_values.back().first, 10);
 }
 
 TEST_F(FakeDriveServiceTest, DownloadFile_NonexistingFile) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/root_feed.json"));
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   const GURL kContentUrl("https://non_existing_content_url/");
   const base::FilePath kOutputFilePath =
       temp_dir.path().AppendASCII("whatever.txt");
   GDataErrorCode error = GDATA_OTHER_ERROR;
   base::FilePath output_file_path;
   fake_service_.DownloadFile(
       base::FilePath::FromUTF8Unsafe("/drive/whatever.txt"),  // virtual path
       kOutputFilePath,
       kContentUrl,
       test_util::CreateCopyResultCallback(&error, &output_file_path),
-      GetContentCallback());
+      GetContentCallback(),
+      ProgressCallback());
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(HTTP_NOT_FOUND, error);
 }
 
 TEST_F(FakeDriveServiceTest, DownloadFile_Offline) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/root_feed.json"));
   fake_service_.set_offline(true);
 
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   const GURL kContentUrl("https://file_content_url/");
   const base::FilePath kOutputFilePath =
       temp_dir.path().AppendASCII("whatever.txt");
   GDataErrorCode error = GDATA_OTHER_ERROR;
   base::FilePath output_file_path;
   fake_service_.DownloadFile(
       base::FilePath::FromUTF8Unsafe("/drive/whatever.txt"),  // virtual path
       kOutputFilePath,
       kContentUrl,
       test_util::CreateCopyResultCallback(&error, &output_file_path),
-      GetContentCallback());
+      GetContentCallback(),
+      ProgressCallback());
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
 }
 
 TEST_F(FakeDriveServiceTest, CopyHostedDocument_ExistingHostedDocument) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/root_feed.json"));
   ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi(
       "chromeos/gdata/account_metadata.json"));
@@ skipping 691 matching lines @@
       15,
       "file:2_file_resource_id",
       "\"HhMOFgxXHit7ImBr\"",
       test_util::CreateCopyResultCallback(&error, &upload_location));
   message_loop_.RunUntilIdle();
 
   ASSERT_EQ(HTTP_SUCCESS, error);
 
   UploadRangeResponse response;
   scoped_ptr<ResourceEntry> entry;
-  std::vector<int64> upload_progress_values;
+  std::vector<test_util::ProgressInfo> upload_progress_values;
   fake_service_.ResumeUpload(
       UPLOAD_EXISTING_FILE,
       base::FilePath(FILE_PATH_LITERAL("drive/File 1.txt")),
       upload_location,
       0, 13, 15, "text/plain",
       scoped_refptr<net::IOBuffer>(),
       test_util::CreateCopyResultCallback(&response, &entry),
-      base::Bind(&AppendProgressCallbackResult, &upload_progress_values));
+      base::Bind(&test_util::AppendProgressCallbackResult,
+                 &upload_progress_values));
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code);
   EXPECT_FALSE(entry.get());
   ASSERT_TRUE(!upload_progress_values.empty());
   EXPECT_TRUE(base::STLIsSorted(upload_progress_values));
-  EXPECT_GE(upload_progress_values.front(), 0);
-  EXPECT_LE(upload_progress_values.back(), 13);
+  EXPECT_GE(upload_progress_values.front().first, 0);
+  EXPECT_LE(upload_progress_values.back().first, 13);
 
   upload_progress_values.clear();
   fake_service_.ResumeUpload(
       UPLOAD_EXISTING_FILE,
       base::FilePath(FILE_PATH_LITERAL("drive/File 1.txt")),
       upload_location,
       13, 15, 15, "text/plain",
       scoped_refptr<net::IOBuffer>(),
       test_util::CreateCopyResultCallback(&response, &entry),
-      base::Bind(&AppendProgressCallbackResult, &upload_progress_values));
+      base::Bind(&test_util::AppendProgressCallbackResult,
+                 &upload_progress_values));
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, response.code);
   EXPECT_TRUE(entry.get());
   EXPECT_EQ(15L, entry->file_size());
   EXPECT_TRUE(Exists(entry->resource_id()));
   ASSERT_TRUE(!upload_progress_values.empty());
   EXPECT_TRUE(base::STLIsSorted(upload_progress_values));
-  EXPECT_GE(upload_progress_values.front(), 0);
-  EXPECT_LE(upload_progress_values.back(), 2);
+  EXPECT_GE(upload_progress_values.front().first, 0);
+  EXPECT_LE(upload_progress_values.back().first, 2);
 }
 
 TEST_F(FakeDriveServiceTest, ResumeUpload_NewFile) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/root_feed.json"));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_location;
   fake_service_.InitiateUploadNewFile(
       base::FilePath(FILE_PATH_LITERAL("drive/Directory 1/new file.foo")),
       "test/foo",
       15,
       "folder:1_folder_resource_id",
       "new file.foo",
       test_util::CreateCopyResultCallback(&error, &upload_location));
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_FALSE(upload_location.is_empty());
   EXPECT_NE(GURL("https://1_folder_resumable_create_media_link"),
             upload_location);
 
   UploadRangeResponse response;
   scoped_ptr<ResourceEntry> entry;
-  std::vector<int64> upload_progress_values;
+  std::vector<test_util::ProgressInfo> upload_progress_values;
   fake_service_.ResumeUpload(
       UPLOAD_NEW_FILE,
       base::FilePath(FILE_PATH_LITERAL("drive/Directory 1/new file.foo")),
       upload_location,
       0, 13, 15, "test/foo",
       scoped_refptr<net::IOBuffer>(),
       test_util::CreateCopyResultCallback(&response, &entry),
-      base::Bind(&AppendProgressCallbackResult, &upload_progress_values));
+      base::Bind(&test_util::AppendProgressCallbackResult,
+                 &upload_progress_values));
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code);
   EXPECT_FALSE(entry.get());
   ASSERT_TRUE(!upload_progress_values.empty());
   EXPECT_TRUE(base::STLIsSorted(upload_progress_values));
-  EXPECT_GE(upload_progress_values.front(), 0);
-  EXPECT_LE(upload_progress_values.back(), 13);
+  EXPECT_GE(upload_progress_values.front().first, 0);
+  EXPECT_LE(upload_progress_values.back().first, 13);
 
   upload_progress_values.clear();
   fake_service_.ResumeUpload(
       UPLOAD_NEW_FILE,
       base::FilePath(FILE_PATH_LITERAL("drive/Directory 1/new file.foo")),
       upload_location,
       13, 15, 15, "test/foo",
       scoped_refptr<net::IOBuffer>(),
       test_util::CreateCopyResultCallback(&response, &entry),
-      base::Bind(&AppendProgressCallbackResult, &upload_progress_values));
+      base::Bind(&test_util::AppendProgressCallbackResult,
+                 &upload_progress_values));
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(HTTP_CREATED, response.code);
   EXPECT_TRUE(entry.get());
   EXPECT_EQ(15L, entry->file_size());
   EXPECT_TRUE(Exists(entry->resource_id()));
   ASSERT_TRUE(!upload_progress_values.empty());
   EXPECT_TRUE(base::STLIsSorted(upload_progress_values));
-  EXPECT_GE(upload_progress_values.front(), 0);
-  EXPECT_LE(upload_progress_values.back(), 2);
+  EXPECT_GE(upload_progress_values.front().first, 0);
+  EXPECT_LE(upload_progress_values.back().first, 2);
 }
 
 TEST_F(FakeDriveServiceTest, AddNewFile_ToRootDirectory) {
   ASSERT_TRUE(fake_service_.LoadResourceListForWapi(
       "chromeos/gdata/root_feed.json"));
   ASSERT_TRUE(fake_service_.LoadAccountMetadataForWapi(
       "chromeos/gdata/account_metadata.json"));
 
   int64 old_largest_change_id = GetLargestChangeByAboutResource();
 
@@ skipping 201 matching lines @@
       test_util::CreateCopyResultCallback(&error, &resource_entry));
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(GDATA_NO_CONNECTION, error);
   EXPECT_FALSE(resource_entry);
 }
 
 }  // namespace
 
 }  // namespace google_apis