Home | History | Annotate | Download | only in sync_driver 
      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 
     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 
     20 FakeDataTypeController::~FakeDataTypeController() {
     21 }
     22 
     23 // NOT_RUNNING ->MODEL_LOADED |MODEL_STARTING.
     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 
     43 void FakeDataTypeController::OnModelLoaded() {
     44   NOTREACHED();
     45 }
     46 
     47 // MODEL_LOADED -> MODEL_STARTING.
     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|)
     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
     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 
    114 ModelType FakeDataTypeController::type() const {
    115   return type_;
    116 }
    117 
    118 std::string FakeDataTypeController::name() const {
    119   return ModelTypeToString(type_);
    120 }
    121 
    122 syncer::ModelSafeGroup FakeDataTypeController::model_safe_group() const {
    123   return syncer::GROUP_PASSIVE;
    124 }
    125 
    126 ChangeProcessor* FakeDataTypeController::GetChangeProcessor() const {
    127   return NULL;
    128 }
    129 
    130 DataTypeController::State FakeDataTypeController::state() const {
    131   return state_;
    132 }
    133 
    134 void FakeDataTypeController::OnSingleDatatypeUnrecoverableError(
    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::SetModelLoadError(syncer::SyncError error) {
    145   load_error_ = error;
    146 }
    147 
    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