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