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 "components/sync_driver/fake_data_type_controller.h"
6
7 #include "testing/gmock/include/gmock/gmock.h"
8 #include "testing/gtest/include/gtest/gtest.h"
9
10 using syncer::ModelType;
11 namespace browser_sync {
12
FakeDataTypeController(ModelType type)13 FakeDataTypeController::FakeDataTypeController(ModelType type)
14 : DataTypeController(base::MessageLoopProxy::current(), base::Closure(),
15 DisableTypeCallback()),
16 state_(NOT_RUNNING),
17 model_load_delayed_(false),
18 type_(type) {}
19
~FakeDataTypeController()20 FakeDataTypeController::~FakeDataTypeController() {
21 }
22
23 // NOT_RUNNING ->MODEL_LOADED |MODEL_STARTING.
LoadModels(const ModelLoadCallback & model_load_callback)24 void FakeDataTypeController::LoadModels(
25 const ModelLoadCallback& model_load_callback) {
26 if (state_ != NOT_RUNNING) {
27 ADD_FAILURE();
28 return;
29 }
30
31 if (model_load_delayed_ == false) {
32 if (load_error_.IsSet())
33 state_ = DISABLED;
34 else
35 state_ = MODEL_LOADED;
36 model_load_callback.Run(type(), load_error_);
37 } else {
38 model_load_callback_ = model_load_callback;
39 state_ = MODEL_STARTING;
40 }
41 }
42
OnModelLoaded()43 void FakeDataTypeController::OnModelLoaded() {
44 NOTREACHED();
45 }
46
47 // MODEL_LOADED -> MODEL_STARTING.
StartAssociating(const StartCallback & start_callback)48 void FakeDataTypeController::StartAssociating(
49 const StartCallback& start_callback) {
50 last_start_callback_ = start_callback;
51 state_ = ASSOCIATING;
52 }
53
54 // MODEL_STARTING | ASSOCIATING -> RUNNING | DISABLED | NOT_RUNNING
55 // (depending on |result|)
FinishStart(StartResult result)56 void FakeDataTypeController::FinishStart(StartResult result) {
57 // We should have a callback from Start().
58 if (last_start_callback_.is_null()) {
59 ADD_FAILURE();
60 return;
61 }
62
63 // Set |state_| first below since the callback may call state().
64 syncer::SyncMergeResult local_merge_result(type());
65 syncer::SyncMergeResult syncer_merge_result(type());
66 if (result <= OK_FIRST_RUN) {
67 state_ = RUNNING;
68 } else if (result == ASSOCIATION_FAILED) {
69 state_ = DISABLED;
70 local_merge_result.set_error(
71 syncer::SyncError(FROM_HERE,
72 syncer::SyncError::DATATYPE_ERROR,
73 "Association failed",
74 type()));
75 } else {
76 state_ = NOT_RUNNING;
77 local_merge_result.set_error(
78 syncer::SyncError(FROM_HERE,
79 syncer::SyncError::DATATYPE_ERROR,
80 "Fake error",
81 type()));
82 }
83 StartCallback start_callback = last_start_callback_;
84 last_start_callback_.Reset();
85 start_callback.Run(result,
86 local_merge_result,
87 syncer_merge_result);
88 }
89
90 // * -> NOT_RUNNING
Stop()91 void FakeDataTypeController::Stop() {
92 state_ = NOT_RUNNING;
93 if (!model_load_callback_.is_null()) {
94 // Real data type controllers run the callback and specify "ABORTED" as an
95 // error. We should probably find a way to use the real code and mock out
96 // unnecessary pieces.
97 SimulateModelLoadFinishing();
98 }
99
100 // The DTM still expects |last_start_callback_| to be called back.
101 if (!last_start_callback_.is_null()) {
102 syncer::SyncError error(FROM_HERE,
103 syncer::SyncError::DATATYPE_ERROR,
104 "Fake error",
105 type_);
106 syncer::SyncMergeResult local_merge_result(type_);
107 local_merge_result.set_error(error);
108 last_start_callback_.Run(ABORTED,
109 local_merge_result,
110 syncer::SyncMergeResult(type_));
111 }
112 }
113
type() const114 ModelType FakeDataTypeController::type() const {
115 return type_;
116 }
117
name() const118 std::string FakeDataTypeController::name() const {
119 return ModelTypeToString(type_);
120 }
121
model_safe_group() const122 syncer::ModelSafeGroup FakeDataTypeController::model_safe_group() const {
123 return syncer::GROUP_PASSIVE;
124 }
125
GetChangeProcessor() const126 ChangeProcessor* FakeDataTypeController::GetChangeProcessor() const {
127 return NULL;
128 }
129
state() const130 DataTypeController::State FakeDataTypeController::state() const {
131 return state_;
132 }
133
OnSingleDatatypeUnrecoverableError(const tracked_objects::Location & from_here,const std::string & message)134 void FakeDataTypeController::OnSingleDatatypeUnrecoverableError(
135 const tracked_objects::Location& from_here,
136 const std::string& message) {
137 ADD_FAILURE() << message;
138 }
139
SetDelayModelLoad()140 void FakeDataTypeController::SetDelayModelLoad() {
141 model_load_delayed_ = true;
142 }
143
SetModelLoadError(syncer::SyncError error)144 void FakeDataTypeController::SetModelLoadError(syncer::SyncError error) {
145 load_error_ = error;
146 }
147
SimulateModelLoadFinishing()148 void FakeDataTypeController::SimulateModelLoadFinishing() {
149 ModelLoadCallback model_load_callback = model_load_callback_;
150 model_load_callback.Run(type(), load_error_);
151 model_load_callback_.Reset();
152 }
153
154 } // namespace browser_sync
155