Home | History | Annotate | Download | only in drive_backend 
      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<TaskBlocker>(),
     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<TaskBlocker>(),
     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<TaskBlocker> task_blocker) {
     49   return make_scoped_ptr(new SyncTaskToken(
     50       manager,
     51       task_runner,
     52       token_id,
     53       task_blocker.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                                           task_blocker_.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_task_blocker(
     94     scoped_ptr<TaskBlocker> task_blocker) {
     95   task_blocker_ = task_blocker.Pass();
     96 }
     97 
     98 const TaskBlocker* SyncTaskToken::task_blocker() const {
     99   return task_blocker_.get();
    100 }
    101 
    102 void SyncTaskToken::clear_task_blocker() {
    103   task_blocker_.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(
    142     const base::WeakPtr<SyncTaskManager>& manager,
    143     const scoped_refptr<base::SequencedTaskRunner>& task_runner,
    144     int64 token_id,
    145     scoped_ptr<TaskBlocker> task_blocker,
    146     const SyncStatusCallback& callback)
    147     : manager_(manager),
    148       task_runner_(task_runner),
    149       token_id_(token_id),
    150       callback_(callback),
    151       task_blocker_(task_blocker.Pass()) {
    152 }
    153 
    154 }  // namespace drive_backend
    155 }  // namespace sync_file_system
    156