Enrich fileBrowserPrivate.onFileTransfersUpdated event to support displaying total number of jobs.

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/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 686 matching lines @@
 JobScheduler::JobEntry* JobScheduler::CreateNewJob(JobType type) {
   JobEntry* job = new JobEntry(type);
   job->job_info.job_id = job_map_.Add(job);  // Takes the ownership of |job|.
   return job;
 }
 
 void JobScheduler::StartJob(JobEntry* job) {
   DCHECK(!job->task.is_null());
 
   QueueJob(job->job_info.job_id);
+  QueueType queue_type = GetJobQueueType(job->job_info.job_type);
+  job->job_info.num_total_jobs = queue_[queue_type]->GetNumberOfJobs();
+  if (queue_type == FILE_QUEUE) {
+    job->job_info.state = STATE_NEW;
+  }
   NotifyJobAdded(job->job_info);
+  if (job->job_info.num_total_jobs == 1) {
+    base::TimeDelta delay = base::TimeDelta::FromMilliseconds(500);

[hirono, 2014/08/27 08:37:20]

It looks to affect actual performance.
Can we delay events instead of jobs?

[iseki, 2014/08/28 07:13:32]

Done.

+    wait_until_ = std::max(wait_until_, base::Time::Now() + delay);
+  }
   DoJobLoop(GetJobQueueType(job->job_info.job_type));
 }
 
 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;
 
@@ skipping 41 matching lines @@
   JobID job_id = -1;
   if (!queue_[queue_type]->PopForRun(accepted_priority, &job_id))
     return;
 
   JobEntry* entry = job_map_.Lookup(job_id);
   DCHECK(entry);
 
   JobInfo* job_info = &entry->job_info;
   job_info->state = STATE_RUNNING;
   job_info->start_time = now;
+  job_info->num_total_jobs = queue_[queue_type]->GetNumberOfJobs();
   NotifyJobUpdated(*job_info);
 
   entry->cancel_callback = entry->task.Run();
 
   UpdateWait();
 
   logger_->Log(logging::LOG_INFO,
                "Job started: %s - %s",
                job_info->ToString().c_str(),
                GetQueueInfo(queue_type).c_str());
@@ skipping 67 matching lines @@
     UpdateWait();
   } else {
     throttle_count_ = 0;
   }
 
   const bool should_retry =
       is_server_error && job_entry->retry_count < kMaxRetryCount;
   if (should_retry) {
     job_entry->cancel_callback.Reset();
     job_info->state = STATE_RETRY;
+    QueueType queue_type = GetJobQueueType(job_info->job_type);
+    job_info->num_total_jobs = queue_[queue_type]->GetNumberOfJobs();
     NotifyJobUpdated(*job_info);
 
     ++job_entry->retry_count;
 
     // Requeue the job.
     QueueJob(job_id);
   } else {
+    QueueType queue_type = GetJobQueueType(job_info->job_type);
+    job_info->num_total_jobs = queue_[queue_type]->GetNumberOfJobs();
     NotifyJobDone(*job_info, error);
     // The job has finished, no retry will happen in the scheduler. Now we can
     // remove the job info from the map.
     job_map_.Remove(job_id);
   }
 
   // Post a task to continue the job loop.  This allows us to finish handling
   // the current job before starting the next one.
   base::MessageLoopProxy::current()->PostTask(FROM_HERE,
       base::Bind(&JobScheduler::DoJobLoop,
@@ skipping 157 matching lines @@
     callback.Run(error, entry.Pass());
 }
 
 void JobScheduler::UpdateProgress(JobID job_id, int64 progress, int64 total) {
   JobEntry* job_entry = job_map_.Lookup(job_id);
   DCHECK(job_entry);
 
   job_entry->job_info.num_completed_bytes = progress;
   if (total != -1)
     job_entry->job_info.num_total_bytes = total;
+  QueueType queue_type = GetJobQueueType(job_entry->job_info.job_type);
+  job_entry->job_info.num_total_jobs = queue_[queue_type]->GetNumberOfJobs();
   NotifyJobUpdated(job_entry->job_info);
 }
 
 void JobScheduler::OnConnectionTypeChanged(
     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().
@@ skipping 41 matching lines @@
   logger_->Log(logging::LOG_INFO,
                "Job aborted: %s => %s (elapsed time: %sms) - %s",
                job->job_info.ToString().c_str(),
                GDataErrorCodeToString(error).c_str(),
                base::Int64ToString(elapsed.InMilliseconds()).c_str(),
                GetQueueInfo(queue_type).c_str());
 
   base::Callback<void(google_apis::GDataErrorCode)> callback =
       job->abort_callback;
   queue_[GetJobQueueType(job->job_info.job_type)]->Remove(job->job_info.job_id);
+  job->job_info.num_total_jobs = queue_[queue_type]->GetNumberOfJobs();
   NotifyJobDone(job->job_info, error);
   job_map_.Remove(job->job_info.job_id);
   base::MessageLoopProxy::current()->PostTask(FROM_HERE,
                                               base::Bind(callback, error));
 }
 
 void JobScheduler::NotifyJobAdded(const JobInfo& job_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   FOR_EACH_OBSERVER(JobListObserver, observer_list_, OnJobAdded(job_info));
 }
@@ skipping 22 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