Add histograms about files copied or movied files from or to Drive.

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"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/drive/event_logger.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "google_apis/drive/drive_api_parser.h"
 
 using content::BrowserThread;
@@ skipping 108 matching lines @@
 google_apis::CancelCallback RunResumeUploadFile(
     DriveUploaderInterface* uploader,
     const ResumeUploadFileParams& params) {
   return uploader->ResumeUploadFile(params.upload_location,
                                     params.local_file_path,
                                     params.content_type,
                                     params.callback,
                                     params.progress_callback);
 }
 
+// Collects information about sizes of files copied or moved from or to Drive
+// Otherwise does nothing. Temporary for crbug.com/229650.
+void CollectCopyHistogramSample(const std::string& histogram_name, int64 size) {
+  UMA_HISTOGRAM_CUSTOM_COUNTS(
+      histogram_name, size / 1024, 1, 1024 * 1024 /* 1 GB */, 50);

[Ilya Sherman, 2014/10/09 04:44:51]

Btw, did you consider using UMA_HISTOGRAM_MEMORY_MB?  I do realize that that
cuts off at 1MB rather than at 1KB, as you've defined here.

[Ilya Sherman, 2014/10/09 04:44:51]

Unfortunately, this won't work.  The UMA_HISTOGRAM_* macros require the
histogram name to be a run-time constant, as they declare a static local
variable to cache the constructed histogram.  You'll need to either define this
as a macro that wraps the UMA_HISTOGRAM_* macros, or make separate calls for
each differently named histogram.

[mtomasz, 2014/10/14 04:46:00]

Yep, I considered, but the range is just not good for us here. We need to
register very small files as well as large files (1GB).

[mtomasz, 2014/10/14 04:46:00]

Done.

+}
+
+// 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) {
+  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)));
+}
+
 }  // namespace
 
 // Metadata jobs are cheap, so we run them concurrently. File jobs run serially.
 const int JobScheduler::kMaxJobCount[] = {
   5,  // METADATA_QUEUE
   1,  // FILE_QUEUE
 };
 
 JobScheduler::JobEntry::JobEntry(JobType type)
     : job_info(type),
       context(ClientContext(USER_INITIATED)),
       retry_count(0) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 JobScheduler::JobEntry::~JobEntry() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 struct JobScheduler::ResumeUploadParams {
   base::FilePath drive_file_path;
   base::FilePath local_file_path;
   std::string content_type;
 };
 
-JobScheduler::JobScheduler(
-    PrefService* pref_service,
-    EventLogger* logger,
-    DriveServiceInterface* drive_service,
-    base::SequencedTaskRunner* blocking_task_runner)
+JobScheduler::JobScheduler(PrefService* pref_service,
+                           EventLogger* logger,
+                           DriveServiceInterface* drive_service,
+                           base::SequencedTaskRunner* blocking_task_runner)
     : throttle_count_(0),
       wait_until_(base::Time::Now()),
       disable_throttling_(false),
       logger_(logger),
       drive_service_(drive_service),
+      blocking_task_runner_(blocking_task_runner),
       uploader_(new DriveUploader(drive_service, blocking_task_runner)),
       pref_service_(pref_service),
       weak_ptr_factory_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   for (int i = 0; i < NUM_QUEUES; ++i)
     queue_[i].reset(new JobQueue(kMaxJobCount[i], NUM_CONTEXT_TYPES));
 
   net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
 }
@@ skipping 386 matching lines @@
 JobID JobScheduler::DownloadFile(
     const base::FilePath& virtual_path,
     int64 expected_file_size,
     const base::FilePath& local_cache_path,
     const std::string& resource_id,
     const ClientContext& context,
     const google_apis::DownloadActionCallback& download_action_callback,
     const google_apis::GetContentCallback& get_content_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
+  // Temporary histogram for crbug.com/229650.
+  CollectCopyHistogramSample("Drive.DownloadFromDriveFileSizeKB",
+                             expected_file_size);
+
   JobEntry* new_job = CreateNewJob(TYPE_DOWNLOAD_FILE);
   new_job->job_info.file_path = virtual_path;
   new_job->job_info.num_total_bytes = expected_file_size;
   new_job->context = context;
   new_job->task = base::Bind(
       &DriveServiceInterface::DownloadFile,
       base::Unretained(drive_service_),
       local_cache_path,
       resource_id,
       base::Bind(&JobScheduler::OnDownloadActionJobDone,
@@ skipping 13 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.UploadToDriveFileSizeKB");
+
   JobEntry* new_job = CreateNewJob(TYPE_UPLOAD_NEW_FILE);
   new_job->job_info.file_path = drive_file_path;
   new_job->context = context;
 
   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;
@@ skipping 18 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.UploadToDriveFileSizeKB");
+
   JobEntry* new_job = CreateNewJob(TYPE_UPLOAD_EXISTING_FILE);
   new_job->job_info.file_path = drive_file_path;
   new_job->context = context;
 
   UploadExistingFileParams params;
   params.resource_id = resource_id;
   params.local_file_path = local_file_path;
   params.content_type = content_type;
   params.options = options;
 
@@ skipping 53 matching lines @@
 void JobScheduler::QueueJob(JobID job_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   JobEntry* job_entry = job_map_.Lookup(job_id);
   DCHECK(job_entry);
   const JobInfo& job_info = job_entry->job_info;
 
   const QueueType queue_type = GetJobQueueType(job_info.job_type);
   queue_[queue_type]->Push(job_id, job_entry->context.type);
 
+  // Temporary histogram for crbug.com/229650.
+  if (job_info.job_type == TYPE_DOWNLOAD_FILE ||
+      job_info.job_type == TYPE_UPLOAD_EXISTING_FILE ||
+      job_info.job_type == TYPE_UPLOAD_NEW_FILE) {
+    std::vector<JobID> jobs_with_the_same_priority;
+    queue_[queue_type]->GetQueuedJobs(job_entry->context.type,
+                                      &jobs_with_the_same_priority);
+    DCHECK(!jobs_with_the_same_priority.empty());
+
+    const size_t blocking_jobs_count = jobs_with_the_same_priority.size() - 1;
+    UMA_HISTOGRAM_COUNTS_10000("Drive.TransferBlockedOnJobs",
+                               blocking_jobs_count);
+  }
+
   const std::string retry_prefix = job_entry->retry_count > 0 ?
       base::StringPrintf(" (retry %d)", job_entry->retry_count) : "";
   logger_->Log(logging::LOG_INFO,
                "Job queued%s: %s - %s",
                retry_prefix.c_str(),
                job_info.ToString().c_str(),
                GetQueueInfo(queue_type).c_str());
 }
 
 void JobScheduler::DoJobLoop(QueueType queue_type) {
@@ skipping 402 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