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 <utility>
8
9 #include "base/bind.h"
10 #include "base/logging.h"
11 #include "base/memory/ptr_util.h"
12 #include "base/threading/thread_task_runner_handle.h"
13 #include "base/trace_event/trace_event.h"
14 #include "chrome/browser/sync_file_system/drive_backend/sync_task_manager.h"
15 #include "chrome/browser/sync_file_system/drive_backend/task_dependency_manager.h"
16
17 namespace sync_file_system {
18 namespace drive_backend {
19
20 const int64_t SyncTaskToken::kTestingTaskTokenID = -1;
21 const int64_t SyncTaskToken::kForegroundTaskTokenID = 0;
22 const int64_t SyncTaskToken::kMinimumBackgroundTaskTokenID = 1;
23
24 // static
CreateForTesting(const SyncStatusCallback & callback)25 std::unique_ptr<SyncTaskToken> SyncTaskToken::CreateForTesting(
26 const SyncStatusCallback& callback) {
27 return base::WrapUnique(new SyncTaskToken(base::WeakPtr<SyncTaskManager>(),
28 base::ThreadTaskRunnerHandle::Get(),
29 kTestingTaskTokenID,
30 nullptr, // task_blocker
31 callback));
32 }
33
34 // static
CreateForForegroundTask(const base::WeakPtr<SyncTaskManager> & manager,base::SequencedTaskRunner * task_runner)35 std::unique_ptr<SyncTaskToken> SyncTaskToken::CreateForForegroundTask(
36 const base::WeakPtr<SyncTaskManager>& manager,
37 base::SequencedTaskRunner* task_runner) {
38 return base::WrapUnique(new SyncTaskToken(manager, task_runner,
39 kForegroundTaskTokenID,
40 nullptr, // task_blocker
41 SyncStatusCallback()));
42 }
43
44 // static
CreateForBackgroundTask(const base::WeakPtr<SyncTaskManager> & manager,base::SequencedTaskRunner * task_runner,int64_t token_id,std::unique_ptr<TaskBlocker> task_blocker)45 std::unique_ptr<SyncTaskToken> SyncTaskToken::CreateForBackgroundTask(
46 const base::WeakPtr<SyncTaskManager>& manager,
47 base::SequencedTaskRunner* task_runner,
48 int64_t token_id,
49 std::unique_ptr<TaskBlocker> task_blocker) {
50 return base::WrapUnique(new SyncTaskToken(manager, task_runner, token_id,
51 std::move(task_blocker),
52 SyncStatusCallback()));
53 }
54
UpdateTask(const base::Location & location,const SyncStatusCallback & callback)55 void SyncTaskToken::UpdateTask(const base::Location& location,
56 const SyncStatusCallback& callback) {
57 DCHECK(callback_.is_null());
58 location_ = location;
59 callback_ = callback;
60 DVLOG(2) << "Token updated: " << location_.ToString();
61 }
62
~SyncTaskToken()63 SyncTaskToken::~SyncTaskToken() {}
64
65 // static
WrapToCallback(std::unique_ptr<SyncTaskToken> token)66 SyncStatusCallback SyncTaskToken::WrapToCallback(
67 std::unique_ptr<SyncTaskToken> token) {
68 return base::Bind(&SyncTaskManager::NotifyTaskDone, base::Passed(&token));
69 }
70
set_task_blocker(std::unique_ptr<TaskBlocker> task_blocker)71 void SyncTaskToken::set_task_blocker(
72 std::unique_ptr<TaskBlocker> task_blocker) {
73 task_blocker_ = std::move(task_blocker);
74 }
75
task_blocker() const76 const TaskBlocker* SyncTaskToken::task_blocker() const {
77 return task_blocker_.get();
78 }
79
clear_task_blocker()80 void SyncTaskToken::clear_task_blocker() {
81 task_blocker_.reset();
82 }
83
InitializeTaskLog(const std::string & task_description)84 void SyncTaskToken::InitializeTaskLog(const std::string& task_description) {
85 task_log_.reset(new TaskLogger::TaskLog);
86 task_log_->start_time = base::TimeTicks::Now();
87 task_log_->task_description = task_description;
88
89 TRACE_EVENT_NESTABLE_ASYNC_BEGIN1(
90 TRACE_DISABLED_BY_DEFAULT("SyncFileSystem"), "SyncTask",
91 TRACE_ID_LOCAL(task_log_->log_id), "task_description", task_description);
92 }
93
FinalizeTaskLog(const std::string & result_description)94 void SyncTaskToken::FinalizeTaskLog(const std::string& result_description) {
95 TRACE_EVENT_NESTABLE_ASYNC_END1(TRACE_DISABLED_BY_DEFAULT("SyncFileSystem"),
96 "SyncTask", TRACE_ID_LOCAL(task_log_->log_id),
97 "result_description", result_description);
98
99 DCHECK(task_log_);
100 task_log_->result_description = result_description;
101 task_log_->end_time = base::TimeTicks::Now();
102 }
103
RecordLog(const std::string & message)104 void SyncTaskToken::RecordLog(const std::string& message) {
105 DCHECK(task_log_);
106 task_log_->details.push_back(message);
107 }
108
SetTaskLog(std::unique_ptr<TaskLogger::TaskLog> task_log)109 void SyncTaskToken::SetTaskLog(std::unique_ptr<TaskLogger::TaskLog> task_log) {
110 task_log_ = std::move(task_log);
111 }
112
PassTaskLog()113 std::unique_ptr<TaskLogger::TaskLog> SyncTaskToken::PassTaskLog() {
114 return std::move(task_log_);
115 }
116
SyncTaskToken(const base::WeakPtr<SyncTaskManager> & manager,const scoped_refptr<base::SequencedTaskRunner> & task_runner,int64_t token_id,std::unique_ptr<TaskBlocker> task_blocker,const SyncStatusCallback & callback)117 SyncTaskToken::SyncTaskToken(
118 const base::WeakPtr<SyncTaskManager>& manager,
119 const scoped_refptr<base::SequencedTaskRunner>& task_runner,
120 int64_t token_id,
121 std::unique_ptr<TaskBlocker> task_blocker,
122 const SyncStatusCallback& callback)
123 : manager_(manager),
124 task_runner_(task_runner),
125 token_id_(token_id),
126 callback_(callback),
127 task_blocker_(std::move(task_blocker)) {}
128
129 } // namespace drive_backend
130 } // namespace sync_file_system
131