Fire event notification from DriveScheduler.

chrome/browser/chromeos/drive/drive_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/drive_scheduler.h"
 
 #include <math.h>
 
 #include "base/message_loop.h"
 #include "base/prefs/pref_service.h"
@@ skipping 348 matching lines @@
   StartNewJob(new_job.Pass(), TYPE_UPLOAD_EXISTING_FILE);
 }
 
 void DriveScheduler::StartNewJob(scoped_ptr<QueueEntry> job, JobType type) {
   // job_info is owned by job_map_ and released when it is removed in OnJobDone.
   JobInfo* job_info = new JobInfo(type);
   job->job_id = job_info->job_id = job_map_.Add(job_info);
   job_info->file_path = job->drive_file_path;
 
   QueueJob(job.Pass());
+  NotifyJobAdded(*job_info);
   StartJobLoop(GetJobQueueType(type));
 }
 
 void DriveScheduler::QueueJob(scoped_ptr<QueueEntry> job) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   JobInfo* job_info = job_map_.Lookup(job->job_id);
   DCHECK(job_info);
 
   QueueType queue_type = GetJobQueueType(job_info->job_type);
@@ skipping 25 matching lines @@
   // Increment the number of jobs.
   ++jobs_running_[queue_type];
 
   // Should copy before calling queue_.pop_front().
   scoped_ptr<QueueEntry> queue_entry(queue_[queue_type].front());
   queue_[queue_type].pop_front();
 
   JobInfo* job_info = job_map_.Lookup(queue_entry->job_id);
   DCHECK(job_info);
   job_info->state = STATE_RUNNING;
+  NotifyJobUpdated(*job_info);
 
   // The some arguments are evaluated after bind, so we copy the pointer to the
   // QueueEntry
   QueueEntry* entry = queue_entry.get();
 
   switch (job_info->job_type) {
     case TYPE_GET_ABOUT_RESOURCE: {
       drive_service_->GetAboutResource(
           base::Bind(&DriveScheduler::OnGetAboutResourceJobDone,
                      weak_ptr_factory_.GetWeakPtr(),
@@ skipping 263 matching lines @@
   JobInfo* job_info = job_map_.Lookup(queue_entry->job_id);
   DCHECK(job_info);
   QueueType queue_type = GetJobQueueType(job_info->job_type);
 
   // Decrement the number of jobs for this queue.
   --jobs_running_[queue_type];
 
   // Retry, depending on the error.
   if (error == DRIVE_FILE_ERROR_THROTTLED) {
     job_info->state = STATE_RETRY;
+    NotifyJobUpdated(*job_info);
 
     // Requeue the job.
     QueueJob(queue_entry.Pass());
 
     ThrottleAndContinueJobLoop(queue_type);
 
     return scoped_ptr<DriveScheduler::QueueEntry>();
   } else {
+    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. This is the only place of the removal.
     job_map_.Remove(queue_entry->job_id);
 
     ResetThrottleAndContinueJobLoop(queue_type);
 
     // Send the entry back.
     return queue_entry.Pass();
   }
 }
@@ skipping 141 matching lines @@
   queue_entry->upload_completion_callback.Run(
       error, drive_path, file_path, resource_entry.Pass());
 }
 
 void DriveScheduler::UpdateProgress(JobID job_id, int64 progress, int64 total) {
   JobInfo* job_info = job_map_.Lookup(job_id);
   DCHECK(job_info);
 
   job_info->num_completed_bytes = progress;
   job_info->num_total_bytes = total;
+  NotifyJobUpdated(*job_info);
 }
 
 void DriveScheduler::OnConnectionTypeChanged(
     net::NetworkChangeNotifier::ConnectionType type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Resume the job loop if the network is back online. Note that we don't
   // need to check the type of the network as it will be checked in
   // ShouldStopJobLoop() as soon as the loop is resumed.
   if (!net::NetworkChangeNotifier::IsOffline()) {
@@ skipping 42 matching lines @@
   FOR_EACH_OBSERVER(JobListObserver, observer_list_,
                     OnJobDone(job_info, error));
 }
 
 void DriveScheduler::NotifyJobUpdated(const JobInfo& job_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   FOR_EACH_OBSERVER(JobListObserver, observer_list_, OnJobUpdated(job_info));
 }
 
 }  // namespace drive