sync_task_token.cc revision 116680a4aac90f2aa7413d9095a592090648e557 
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
13namespace sync_file_system {
14namespace drive_backend {
15
16const int64 SyncTaskToken::kTestingTaskTokenID = -1;
17const int64 SyncTaskToken::kForegroundTaskTokenID = 0;
18const int64 SyncTaskToken::kMinimumBackgroundTaskTokenID = 1;
19
20// static
21scoped_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
32scoped_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
44scoped_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
57void 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
65SyncTaskToken::~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_ && 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(
79            manager_, task_runner_, token_id_, blocking_factor_.Pass(),
80            SyncStatusCallback())),
81        SYNC_STATUS_OK);
82  }
83}
84
85// static
86SyncStatusCallback SyncTaskToken::WrapToCallback(
87    scoped_ptr<SyncTaskToken> token) {
88  return base::Bind(&SyncTaskManager::NotifyTaskDone, base::Passed(&token));
89}
90
91void SyncTaskToken::set_blocking_factor(
92    scoped_ptr<BlockingFactor> blocking_factor) {
93  blocking_factor_ = blocking_factor.Pass();
94}
95
96const BlockingFactor* SyncTaskToken::blocking_factor() const {
97  return blocking_factor_.get();
98}
99
100void SyncTaskToken::clear_blocking_factor() {
101  blocking_factor_.reset();
102}
103
104void SyncTaskToken::InitializeTaskLog(const std::string& task_description) {
105  task_log_.reset(new TaskLogger::TaskLog);
106  task_log_->start_time = base::TimeTicks::Now();
107  task_log_->task_description = task_description;
108
109  TRACE_EVENT_ASYNC_BEGIN1(
110      TRACE_DISABLED_BY_DEFAULT("SyncFileSystem"),
111      "SyncTask", task_log_->log_id,
112      "task_description", task_description);
113}
114
115void SyncTaskToken::FinalizeTaskLog(const std::string& result_description) {
116  TRACE_EVENT_ASYNC_END1(
117      TRACE_DISABLED_BY_DEFAULT("SyncFileSystem"),
118      "SyncTask", task_log_->log_id,
119      "result_description", result_description);
120
121  DCHECK(task_log_);
122  task_log_->result_description = result_description;
123  task_log_->end_time = base::TimeTicks::Now();
124}
125
126void SyncTaskToken::RecordLog(const std::string& message) {
127  DCHECK(task_log_);
128  task_log_->details.push_back(message);
129}
130
131void SyncTaskToken::SetTaskLog(scoped_ptr<TaskLogger::TaskLog> task_log) {
132  task_log_ = task_log.Pass();
133}
134
135scoped_ptr<TaskLogger::TaskLog> SyncTaskToken::PassTaskLog() {
136  return task_log_.Pass();
137}
138
139SyncTaskToken::SyncTaskToken(const base::WeakPtr<SyncTaskManager>& manager,
140                             base::SequencedTaskRunner* task_runner,
141                             int64 token_id,
142                             scoped_ptr<BlockingFactor> blocking_factor,
143                             const SyncStatusCallback& callback)
144    : manager_(manager),
145      task_runner_(task_runner),
146      token_id_(token_id),
147      callback_(callback),
148      blocking_factor_(blocking_factor.Pass()) {
149}
150
151}  // namespace drive_backend
152}  // namespace sync_file_system
153