chrome/browser/sync_file_system/sync_task_manager.h

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_SYNC_FILE_SYSTEM_SYNC_TASK_MANAGER_H_
   6 #define CHROME_BROWSER_SYNC_FILE_SYSTEM_SYNC_TASK_MANAGER_H_
   7
   8 #include <queue>
   9 #include <vector>
  10
  11 #include "base/callback.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "base/memory/weak_ptr.h"
  14 #include "base/threading/non_thread_safe.h"
  15 #include "chrome/browser/sync_file_system/sync_callbacks.h"
  16 #include "chrome/browser/sync_file_system/sync_status_code.h"
  17 #include "chrome/browser/sync_file_system/sync_task.h"
  18
  19 namespace tracked_objects {
  20 class Location;
  21 }
  22
  23 namespace sync_file_system {
  24
  25 class SyncTaskManager
  26     : public base::NonThreadSafe,
  27       public base::SupportsWeakPtr<SyncTaskManager> {
  28  public:
  29   class TaskToken;
  30   typedef base::Callback<void(const SyncStatusCallback& callback)> Task;
  31
  32   enum Priority {
  33     PRIORITY_LOW,
  34     PRIORITY_MED,
  35     PRIORITY_HIGH,
  36   };
  37
  38   class Client {
  39    public:
  40     virtual ~Client() {}
  41
  42     // Called when the manager is idle.
  43     virtual void MaybeScheduleNextTask() = 0;
  44
  45     // Called when the manager is notified a task is done.
  46     virtual void NotifyLastOperationStatus(
  47         SyncStatusCode last_operation_status,
  48         bool last_operation_used_network) = 0;
  49   };
  50
  51   explicit SyncTaskManager(base::WeakPtr<Client> client);
  52   virtual ~SyncTaskManager();
  53
  54   // This needs to be called to start task scheduling.
  55   // If |status| is not SYNC_STATUS_OK calling this may change the
  56   // service status. This should not be called more than once.
  57   void Initialize(SyncStatusCode status);
  58
  59   // Schedules a task at PRIORITY_MED.
  60   void ScheduleTask(const Task& task,
  61                     const SyncStatusCallback& callback);
  62   void ScheduleSyncTask(scoped_ptr<SyncTask> task,
  63                         const SyncStatusCallback& callback);
  64
  65   // Schedules a task at the given priority.
  66   void ScheduleTaskAtPriority(const Task& task,
  67                               Priority priority,
  68                               const SyncStatusCallback& callback);
  69   void ScheduleSyncTaskAtPriority(scoped_ptr<SyncTask> task,
  70                                   Priority priority,
  71                                   const SyncStatusCallback& callback);
  72
  73   // Runs the posted task only when we're idle.  Returns true if tha task is
  74   // scheduled.
  75   bool ScheduleTaskIfIdle(const Task& task, const SyncStatusCallback& callback);
  76   bool ScheduleSyncTaskIfIdle(scoped_ptr<SyncTask> task,
  77                               const SyncStatusCallback& callback);
  78
  79   void NotifyTaskDone(scoped_ptr<TaskToken> token,
  80                       SyncStatusCode status);
  81
  82  private:
  83   struct PendingTask {
  84     base::Closure task;
  85     Priority priority;
  86     int64 seq;
  87
  88     PendingTask();
  89     PendingTask(const base::Closure& task, Priority pri, int seq);
  90     ~PendingTask();
  91   };
  92
  93   struct PendingTaskComparator {
  94     bool operator()(const PendingTask& left,
  95                     const PendingTask& right) const;
  96   };
  97
  98   // This should be called when an async task needs to get a task token.
  99   scoped_ptr<TaskToken> GetToken(const tracked_objects::Location& from_here);
 100
 101   // Creates a completion callback that calls NotifyTaskDone.
 102   // It is ok to give null |callback|.
 103   SyncStatusCallback CreateCompletionCallback(
 104       scoped_ptr<TaskToken> token,
 105       const SyncStatusCallback& callback);
 106
 107   void PushPendingTask(const base::Closure& closure, Priority priority);
 108
 109   base::WeakPtr<Client> client_;
 110
 111   SyncStatusCode last_operation_status_;
 112   scoped_ptr<SyncTask> running_task_;
 113   SyncStatusCallback current_callback_;
 114
 115   std::priority_queue<PendingTask, std::vector<PendingTask>,
 116                       PendingTaskComparator> pending_tasks_;
 117   int64 pending_task_seq_;
 118
 119   // Absence of |token_| implies a task is running. Incoming tasks should
 120   // wait for the task to finish in |pending_tasks_| if |token_| is null.
 121   // Each task must take TaskToken instance from |token_| and must hold it
 122   // until it finished. And the task must return the instance through
 123   // NotifyTaskDone when the task finished.
 124   scoped_ptr<TaskToken> token_;
 125
 126   DISALLOW_COPY_AND_ASSIGN(SyncTaskManager);
 127 };
 128
 129 }  // namespace sync_file_system
 130
 131 #endif  // CHROME_BROWSER_SYNC_FILE_SYSTEM_SYNC_TASK_MANAGER_H_