Files.app: Obtain total bytes of upload task before starting tasks.

chrome/browser/chromeos/drive/job_scheduler.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/chromeos/drive/job_scheduler.h"
 
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
@@ skipping 129 matching lines @@
 void CollectCopyHistogramSample(const std::string& histogram_name, int64 size) {
   base::HistogramBase* const counter =
       base::Histogram::FactoryGet(histogram_name,
                                   1,
                                   1024 * 1024 /* 1 GB */,
                                   50,
                                   base::Histogram::kUmaTargetedHistogramFlag);
   counter->Add(size / 1024);
 }
 
-// Callback for GetSizeAndCollectCopyHistogramSample().
-void OnGotSizeForCollectCopyHistogramSample(const std::string& histogram_name,
-                                            int64* size) {
-  if (*size != -1)
-    CollectCopyHistogramSample(histogram_name, *size);
-}
-
-// Collects information about sizes of files copied or moved from or to Drive
-// Otherwise does nothing. Temporary for crbug.com/229650.
-void GetSizeAndCollectCopyHistogramSample(
-    base::SequencedTaskRunner* blocking_task_runner,
-    const base::FilePath& local_file_path,
-    const std::string& histogram_name) {
+// Obtains file size to be uploaded for setting total bytes of JobInfo.
+void GetFileSizeForJob(base::SequencedTaskRunner* blocking_task_runner,
+                       const base::FilePath& local_file_path,
+                       const base::Callback<void(int64* size)>& callback) {
   int64* const size = new int64;
   *size = -1;
   blocking_task_runner->PostTaskAndReply(
-      FROM_HERE,
-      base::Bind(base::IgnoreResult(&base::GetFileSize),
-                 local_file_path,
-                 base::Unretained(size)),
-      base::Bind(&OnGotSizeForCollectCopyHistogramSample,
-                 histogram_name,
-                 base::Owned(size)));
+      FROM_HERE, base::Bind(base::IgnoreResult(&base::GetFileSize),
+                            local_file_path, base::Unretained(size)),
+      base::Bind(callback, base::Owned(size)));
 }
 
 }  // namespace
 
 // Metadata jobs are cheap, so we run them concurrently. File jobs run serially.
 const int JobScheduler::kMaxJobCount[] = {
   5,  // METADATA_QUEUE
   1,  // FILE_QUEUE
 };
 
@@ skipping 456 matching lines @@
     const std::string& parent_resource_id,
     const base::FilePath& drive_file_path,
     const base::FilePath& local_file_path,
     const std::string& title,
     const std::string& content_type,
     const DriveUploader::UploadNewFileOptions& options,
     const ClientContext& context,
     const google_apis::FileResourceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  // Temporary histogram for crbug.com/229650.
-  GetSizeAndCollectCopyHistogramSample(
-      blocking_task_runner_, local_file_path, "Drive.UploadToDriveFileSize");
-
   JobEntry* new_job = CreateNewJob(TYPE_UPLOAD_NEW_FILE);
   new_job->job_info.file_path = drive_file_path;
   new_job->context = context;
 
+  GetFileSizeForJob(
+      blocking_task_runner_, local_file_path,
+      base::Bind(&JobScheduler::OnGotFileSizeForJob,
+                 weak_ptr_factory_.GetWeakPtr(), new_job->job_info.job_id,
+                 "Drive.UploadToDriveFileSize"));
+
   UploadNewFileParams params;
   params.parent_resource_id = parent_resource_id;
   params.local_file_path = local_file_path;
   params.title = title;
   params.content_type = content_type;
   params.options = options;
 
   ResumeUploadParams resume_params;
   resume_params.local_file_path = params.local_file_path;
   resume_params.content_type = params.content_type;
@@ skipping 14 matching lines @@
 void JobScheduler::UploadExistingFile(
     const std::string& resource_id,
     const base::FilePath& drive_file_path,
     const base::FilePath& local_file_path,
     const std::string& content_type,
     const DriveUploader::UploadExistingFileOptions& options,
     const ClientContext& context,
     const google_apis::FileResourceCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  // Temporary histogram for crbug.com/229650.
-  GetSizeAndCollectCopyHistogramSample(
-      blocking_task_runner_, local_file_path, "Drive.UploadToDriveFileSize");
-
   JobEntry* new_job = CreateNewJob(TYPE_UPLOAD_EXISTING_FILE);
   new_job->job_info.file_path = drive_file_path;
   new_job->context = context;
 
+  GetFileSizeForJob(
+      blocking_task_runner_, local_file_path,
+      base::Bind(&JobScheduler::OnGotFileSizeForJob,
+                 weak_ptr_factory_.GetWeakPtr(), new_job->job_info.job_id,
+                 "Drive.UploadToDriveFileSize"));
+
   UploadExistingFileParams params;
   params.resource_id = resource_id;
   params.local_file_path = local_file_path;
   params.content_type = content_type;
   params.options = options;
 
   ResumeUploadParams resume_params;
   resume_params.local_file_path = params.local_file_path;
   resume_params.content_type = params.content_type;
 
@@ skipping 397 matching lines @@
     net::NetworkChangeNotifier::ConnectionType type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Resume the job loop.
   // Note that we don't need to check the network connection status as it will
   // be checked in GetCurrentAcceptedPriority().
   for (int i = METADATA_QUEUE; i < NUM_QUEUES; ++i)
     DoJobLoop(static_cast<QueueType>(i));
 }
 
+void JobScheduler::OnGotFileSizeForJob(JobID job_id,
+                                       const std::string& histogram_name,
+                                       int64* size) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (*size == -1)
+    return;
+
+  // Temporary histogram for crbug.com/229650.
+  CollectCopyHistogramSample(histogram_name, *size);
+
+  JobEntry* const job_entry = job_map_.Lookup(job_id);
+  if (!job_entry)
+    return;
+
+  job_entry->job_info.num_total_bytes = *size;
+  NotifyJobUpdated(job_entry->job_info);
+}
+
 JobScheduler::QueueType JobScheduler::GetJobQueueType(JobType type) {
   switch (type) {
     case TYPE_GET_ABOUT_RESOURCE:
     case TYPE_GET_APP_LIST:
     case TYPE_GET_ALL_RESOURCE_LIST:
     case TYPE_GET_RESOURCE_LIST_IN_DIRECTORY:
     case TYPE_SEARCH:
     case TYPE_GET_CHANGE_LIST:
     case TYPE_GET_REMAINING_CHANGE_LIST:
     case TYPE_GET_REMAINING_FILE_LIST:
@@ skipping 68 matching lines @@
     case FILE_QUEUE:
       return "FILE_QUEUE";
     case NUM_QUEUES:
       break;  // This value is just a sentinel. Should never be used.
   }
   NOTREACHED();
   return "";
 }
 
 }  // namespace drive