chrome/browser/sync_file_system/drive_backend/sync_task_token.cc

   1 // Copyright 2014 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 #include "chrome/browser/sync_file_system/drive_backend/sync_task_token.h"
   6
   7 #include "base/bind.h"
   8 #include "base/debug/trace_event.h"
   9 #include "base/thread_task_runner_handle.h"
  10 #include "chrome/browser/sync_file_system/drive_backend/sync_task_manager.h"
  11 #include "chrome/browser/sync_file_system/drive_backend/task_dependency_manager.h"
  12
  13 namespace sync_file_system {
  14 namespace drive_backend {
  15
  16 const int64 SyncTaskToken::kTestingTaskTokenID = -1;
  17 const int64 SyncTaskToken::kForegroundTaskTokenID = 0;
  18 const int64 SyncTaskToken::kMinimumBackgroundTaskTokenID = 1;
  19
  20 // static
  21 scoped_ptr<SyncTaskToken> SyncTaskToken::CreateForTesting(
  22     const SyncStatusCallback& callback) {
  23   return make_scoped_ptr(new SyncTaskToken(
  24       base::WeakPtr<SyncTaskManager>(),
  25       base::ThreadTaskRunnerHandle::Get(),
  26       kTestingTaskTokenID,
  27       scoped_ptr<BlockingFactor>(),
  28       callback));
  29 }
  30
  31 // static
  32 scoped_ptr<SyncTaskToken> SyncTaskToken::CreateForForegroundTask(
  33     const base::WeakPtr<SyncTaskManager>& manager,
  34     base::SequencedTaskRunner* task_runner) {
  35   return make_scoped_ptr(new SyncTaskToken(
  36       manager,
  37       task_runner,
  38       kForegroundTaskTokenID,
  39       scoped_ptr<BlockingFactor>(),
  40       SyncStatusCallback()));
  41 }
  42
  43 // static
  44 scoped_ptr<SyncTaskToken> SyncTaskToken::CreateForBackgroundTask(
  45     const base::WeakPtr<SyncTaskManager>& manager,
  46     base::SequencedTaskRunner* task_runner,
  47     int64 token_id,
  48     scoped_ptr<BlockingFactor> blocking_factor) {
  49   return make_scoped_ptr(new SyncTaskToken(
  50       manager,
  51       task_runner,
  52       token_id,
  53       blocking_factor.Pass(),
  54       SyncStatusCallback()));
  55 }
  56
  57 void SyncTaskToken::UpdateTask(const tracked_objects::Location& location,
  58                                const SyncStatusCallback& callback) {
  59   DCHECK(callback_.is_null());
  60   location_ = location;
  61   callback_ = callback;
  62   DVLOG(2) << "Token updated: " << location_.ToString();
  63 }
  64
  65 SyncTaskToken::~SyncTaskToken() {
  66   // All task on Client must hold TaskToken instance to ensure
  67   // no other tasks are running. Also, as soon as a task finishes to work,
  68   // it must return the token to TaskManager.
  69   // Destroying a token with valid |client| indicates the token was
  70   // dropped by a task without returning.
  71   if (task_runner_.get() && task_runner_->RunsTasksOnCurrentThread() &&
  72       manager_ && manager_->IsRunningTask(token_id_)) {
  73     NOTREACHED()
  74         << "Unexpected TaskToken deletion from: " << location_.ToString();
  75
  76     // Reinitializes the token.
  77     SyncTaskManager::NotifyTaskDone(
  78         make_scoped_ptr(new SyncTaskToken(manager_,
  79                                           task_runner_.get(),
  80                                           token_id_,
  81                                           blocking_factor_.Pass(),
  82                                           SyncStatusCallback())),
  83         SYNC_STATUS_OK);
  84   }
  85 }
  86
  87 // static
  88 SyncStatusCallback SyncTaskToken::WrapToCallback(
  89     scoped_ptr<SyncTaskToken> token) {
  90   return base::Bind(&SyncTaskManager::NotifyTaskDone, base::Passed(&token));
  91 }
  92
  93 void SyncTaskToken::set_blocking_factor(
  94     scoped_ptr<BlockingFactor> blocking_factor) {
  95   blocking_factor_ = blocking_factor.Pass();
  96 }
  97
  98 const BlockingFactor* SyncTaskToken::blocking_factor() const {
  99   return blocking_factor_.get();
 100 }
 101
 102 void SyncTaskToken::clear_blocking_factor() {
 103   blocking_factor_.reset();
 104 }
 105
 106 void SyncTaskToken::InitializeTaskLog(const std::string& task_description) {
 107   task_log_.reset(new TaskLogger::TaskLog);
 108   task_log_->start_time = base::TimeTicks::Now();
 109   task_log_->task_description = task_description;
 110
 111   TRACE_EVENT_ASYNC_BEGIN1(
 112       TRACE_DISABLED_BY_DEFAULT("SyncFileSystem"),
 113       "SyncTask", task_log_->log_id,
 114       "task_description", task_description);
 115 }
 116
 117 void SyncTaskToken::FinalizeTaskLog(const std::string& result_description) {
 118   TRACE_EVENT_ASYNC_END1(
 119       TRACE_DISABLED_BY_DEFAULT("SyncFileSystem"),
 120       "SyncTask", task_log_->log_id,
 121       "result_description", result_description);
 122
 123   DCHECK(task_log_);
 124   task_log_->result_description = result_description;
 125   task_log_->end_time = base::TimeTicks::Now();
 126 }
 127
 128 void SyncTaskToken::RecordLog(const std::string& message) {
 129   DCHECK(task_log_);
 130   task_log_->details.push_back(message);
 131 }
 132
 133 void SyncTaskToken::SetTaskLog(scoped_ptr<TaskLogger::TaskLog> task_log) {
 134   task_log_ = task_log.Pass();
 135 }
 136
 137 scoped_ptr<TaskLogger::TaskLog> SyncTaskToken::PassTaskLog() {
 138   return task_log_.Pass();
 139 }
 140
 141 SyncTaskToken::SyncTaskToken(const base::WeakPtr<SyncTaskManager>& manager,
 142                              base::SequencedTaskRunner* task_runner,
 143                              int64 token_id,
 144                              scoped_ptr<BlockingFactor> blocking_factor,
 145                              const SyncStatusCallback& callback)
 146     : manager_(manager),
 147       task_runner_(task_runner),
 148       token_id_(token_id),
 149       callback_(callback),
 150       blocking_factor_(blocking_factor.Pass()) {
 151 }
 152
 153 }  // namespace drive_backend
 154 }  // namespace sync_file_system