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/non_ui_data_type_controller.h"
      6 
      7 #include "base/logging.h"
      8 #include "base/memory/weak_ptr.h"
      9 #include "components/sync_driver/generic_change_processor_factory.h"
     10 #include "components/sync_driver/shared_change_processor_ref.h"
     11 #include "components/sync_driver/sync_api_component_factory.h"
     12 #include "sync/api/sync_error.h"
     13 #include "sync/api/syncable_service.h"
     14 #include "sync/internal_api/public/base/model_type.h"
     15 #include "sync/util/data_type_histogram.h"
     16 
     17 namespace browser_sync {
     18 
     19 SharedChangeProcessor*
     20 NonUIDataTypeController::CreateSharedChangeProcessor() {
     21   return new SharedChangeProcessor();
     22 }
     23 
     24 NonUIDataTypeController::NonUIDataTypeController(
     25     scoped_refptr<base::MessageLoopProxy> ui_thread,
     26     const base::Closure& error_callback,
     27     const DisableTypeCallback& disable_callback,
     28     SyncApiComponentFactory* sync_factory)
     29     : DataTypeController(ui_thread, error_callback, disable_callback),
     30       sync_factory_(sync_factory),
     31       state_(NOT_RUNNING),
     32       ui_thread_(ui_thread) {
     33 }
     34 
     35 void NonUIDataTypeController::LoadModels(
     36     const ModelLoadCallback& model_load_callback) {
     37   DCHECK(ui_thread_->BelongsToCurrentThread());
     38   DCHECK(!model_load_callback.is_null());
     39   if (state() != NOT_RUNNING) {
     40     model_load_callback.Run(type(),
     41                             syncer::SyncError(FROM_HERE,
     42                                               syncer::SyncError::DATATYPE_ERROR,
     43                                               "Model already running",
     44                                               type()));
     45     return;
     46   }
     47 
     48   state_ = MODEL_STARTING;
     49   // Since we can't be called multiple times before Stop() is called,
     50   // |shared_change_processor_| must be NULL here.
     51   DCHECK(!shared_change_processor_.get());
     52   shared_change_processor_ = CreateSharedChangeProcessor();
     53   DCHECK(shared_change_processor_.get());
     54   model_load_callback_ = model_load_callback;
     55   if (!StartModels()) {
     56     // If we are waiting for some external service to load before associating
     57     // or we failed to start the models, we exit early.
     58     DCHECK(state() == MODEL_STARTING || state() == NOT_RUNNING);
     59     return;
     60   }
     61 
     62   OnModelLoaded();
     63 }
     64 
     65 void NonUIDataTypeController::OnModelLoaded() {
     66   DCHECK_EQ(state_, MODEL_STARTING);
     67   DCHECK(!model_load_callback_.is_null());
     68   state_ = MODEL_LOADED;
     69 
     70   ModelLoadCallback model_load_callback = model_load_callback_;
     71   model_load_callback_.Reset();
     72   model_load_callback.Run(type(), syncer::SyncError());
     73 }
     74 
     75 bool NonUIDataTypeController::StartModels() {
     76   DCHECK_EQ(state_, MODEL_STARTING);
     77   // By default, no additional services need to be started before we can proceed
     78   // with model association.
     79   return true;
     80 }
     81 
     82 void NonUIDataTypeController::StopModels() {
     83   DCHECK(ui_thread_->BelongsToCurrentThread());
     84 }
     85 
     86 void NonUIDataTypeController::StartAssociating(
     87     const StartCallback& start_callback) {
     88   DCHECK(ui_thread_->BelongsToCurrentThread());
     89   DCHECK(!start_callback.is_null());
     90   DCHECK_EQ(state_, MODEL_LOADED);
     91   state_ = ASSOCIATING;
     92 
     93   start_callback_ = start_callback;
     94   if (!StartAssociationAsync()) {
     95     syncer::SyncError error(
     96         FROM_HERE,
     97         syncer::SyncError::DATATYPE_ERROR,
     98         "Failed to post StartAssociation",
     99         type());
    100     syncer::SyncMergeResult local_merge_result(type());
    101     local_merge_result.set_error(error);
    102     StartDoneImpl(ASSOCIATION_FAILED,
    103                   NOT_RUNNING,
    104                   local_merge_result,
    105                   syncer::SyncMergeResult(type()));
    106     // StartDoneImpl should have called ClearSharedChangeProcessor();
    107     DCHECK(!shared_change_processor_.get());
    108     return;
    109   }
    110 }
    111 
    112 void NonUIDataTypeController::Stop() {
    113   DCHECK(ui_thread_->BelongsToCurrentThread());
    114   if (state() == NOT_RUNNING) {
    115     // Stop() should never be called for datatypes that are already stopped.
    116     NOTREACHED();
    117     return;
    118   }
    119 
    120   // Disconnect the change processor. At this point, the
    121   // syncer::SyncableService can no longer interact with the Syncer, even if
    122   // it hasn't finished MergeDataAndStartSyncing.
    123   ClearSharedChangeProcessor();
    124 
    125   // If we haven't finished starting, we need to abort the start.
    126   switch (state()) {
    127     case MODEL_STARTING:
    128       state_ = STOPPING;
    129       AbortModelLoad();
    130       return;  // The datatype was never activated, we're done.
    131     case ASSOCIATING:
    132       state_ = STOPPING;
    133       StartDoneImpl(ABORTED,
    134                     NOT_RUNNING,
    135                     syncer::SyncMergeResult(type()),
    136                     syncer::SyncMergeResult(type()));
    137       // We continue on to deactivate the datatype and stop the local service.
    138       break;
    139     case MODEL_LOADED:
    140     case DISABLED:
    141       // If DTC is loaded or disabled, we never attempted or succeeded
    142       // associating and never activated the datatype. We would have already
    143       // stopped the local service in StartDoneImpl(..).
    144       state_ = NOT_RUNNING;
    145       StopModels();
    146       return;
    147     default:
    148       // Datatype was fully started. Need to deactivate and stop the local
    149       // service.
    150       DCHECK_EQ(state(), RUNNING);
    151       state_ = STOPPING;
    152       StopModels();
    153       break;
    154   }
    155 
    156   // Stop the local service and release our references to it and the
    157   // shared change processor (posts a task to the datatype's thread).
    158   StopLocalServiceAsync();
    159 
    160   state_ = NOT_RUNNING;
    161 }
    162 
    163 std::string NonUIDataTypeController::name() const {
    164   // For logging only.
    165   return syncer::ModelTypeToString(type());
    166 }
    167 
    168 DataTypeController::State NonUIDataTypeController::state() const {
    169   return state_;
    170 }
    171 
    172 void NonUIDataTypeController::OnSingleDatatypeUnrecoverableError(
    173     const tracked_objects::Location& from_here, const std::string& message) {
    174   DCHECK(!ui_thread_->BelongsToCurrentThread());
    175   // TODO(tim): We double-upload some errors.  See bug 383480.
    176   if (!error_callback_.is_null())
    177     error_callback_.Run();
    178   UMA_HISTOGRAM_ENUMERATION("Sync.DataTypeRunFailures",
    179                             ModelTypeToHistogramInt(type()),
    180                             syncer::MODEL_TYPE_COUNT);
    181   ui_thread_->PostTask(from_here,
    182       base::Bind(&NonUIDataTypeController::DisableImpl,
    183                  this,
    184                  from_here,
    185                  message));
    186 }
    187 
    188 NonUIDataTypeController::NonUIDataTypeController()
    189     : DataTypeController(base::MessageLoopProxy::current(), base::Closure(),
    190                          DisableTypeCallback()),
    191       sync_factory_(NULL) {}
    192 
    193 NonUIDataTypeController::~NonUIDataTypeController() {}
    194 
    195 void NonUIDataTypeController::StartDone(
    196     DataTypeController::StartResult start_result,
    197     const syncer::SyncMergeResult& local_merge_result,
    198     const syncer::SyncMergeResult& syncer_merge_result) {
    199   DCHECK(!ui_thread_->BelongsToCurrentThread());
    200 
    201   DataTypeController::State new_state;
    202   if (IsSuccessfulResult(start_result)) {
    203     new_state = RUNNING;
    204   } else {
    205     new_state = (start_result == ASSOCIATION_FAILED ? DISABLED : NOT_RUNNING);
    206   }
    207 
    208   ui_thread_->PostTask(FROM_HERE,
    209       base::Bind(&NonUIDataTypeController::StartDoneImpl,
    210                  this,
    211                  start_result,
    212                  new_state,
    213                  local_merge_result,
    214                  syncer_merge_result));
    215 }
    216 
    217 void NonUIDataTypeController::StartDoneImpl(
    218     DataTypeController::StartResult start_result,
    219     DataTypeController::State new_state,
    220     const syncer::SyncMergeResult& local_merge_result,
    221     const syncer::SyncMergeResult& syncer_merge_result) {
    222   DCHECK(ui_thread_->BelongsToCurrentThread());
    223 
    224   // If we failed to start up, and we haven't been stopped yet, we need to
    225   // ensure we clean up the local service and shared change processor properly.
    226   if (new_state != RUNNING && state() != NOT_RUNNING && state() != STOPPING) {
    227     ClearSharedChangeProcessor();
    228     StopLocalServiceAsync();
    229   }
    230 
    231   // It's possible to have StartDoneImpl called first from the UI thread
    232   // (due to Stop being called) and then posted from the non-UI thread. In
    233   // this case, we drop the second call because we've already been stopped.
    234   if (state_ == NOT_RUNNING) {
    235     DCHECK(start_callback_.is_null());
    236     return;
    237   }
    238 
    239   state_ = new_state;
    240   if (state_ != RUNNING) {
    241     // Start failed.
    242     StopModels();
    243     RecordStartFailure(start_result);
    244   }
    245 
    246   // We have to release the callback before we call it, since it's possible
    247   // invoking the callback will trigger a call to STOP(), which will get
    248   // confused by the non-NULL start_callback_.
    249   StartCallback callback = start_callback_;
    250   start_callback_.Reset();
    251   callback.Run(start_result, local_merge_result, syncer_merge_result);
    252 }
    253 
    254 void NonUIDataTypeController::RecordAssociationTime(base::TimeDelta time) {
    255   DCHECK(!ui_thread_->BelongsToCurrentThread());
    256 #define PER_DATA_TYPE_MACRO(type_str) \
    257     UMA_HISTOGRAM_TIMES("Sync." type_str "AssociationTime", time);
    258   SYNC_DATA_TYPE_HISTOGRAM(type());
    259 #undef PER_DATA_TYPE_MACRO
    260 }
    261 
    262 void NonUIDataTypeController::RecordStartFailure(StartResult result) {
    263   DCHECK(ui_thread_->BelongsToCurrentThread());
    264   UMA_HISTOGRAM_ENUMERATION("Sync.DataTypeStartFailures",
    265                             ModelTypeToHistogramInt(type()),
    266                             syncer::MODEL_TYPE_COUNT);
    267 #define PER_DATA_TYPE_MACRO(type_str) \
    268     UMA_HISTOGRAM_ENUMERATION("Sync." type_str "StartFailure", result, \
    269                               MAX_START_RESULT);
    270   SYNC_DATA_TYPE_HISTOGRAM(type());
    271 #undef PER_DATA_TYPE_MACRO
    272 }
    273 
    274 void NonUIDataTypeController::AbortModelLoad() {
    275   state_ = NOT_RUNNING;
    276   StopModels();
    277   ModelLoadCallback model_load_callback = model_load_callback_;
    278   model_load_callback_.Reset();
    279   model_load_callback.Run(type(),
    280                           syncer::SyncError(FROM_HERE,
    281                                             syncer::SyncError::DATATYPE_ERROR,
    282                                             "ABORTED",
    283                                             type()));
    284 }
    285 
    286 void NonUIDataTypeController::DisableImpl(
    287     const tracked_objects::Location& from_here,
    288     const std::string& message) {
    289   DCHECK(ui_thread_->BelongsToCurrentThread());
    290   if (!disable_callback().is_null())
    291     disable_callback().Run(from_here, message);
    292 }
    293 
    294 bool NonUIDataTypeController::StartAssociationAsync() {
    295   DCHECK(ui_thread_->BelongsToCurrentThread());
    296   DCHECK_EQ(state(), ASSOCIATING);
    297   return PostTaskOnBackendThread(
    298       FROM_HERE,
    299       base::Bind(
    300           &NonUIDataTypeController::StartAssociationWithSharedChangeProcessor,
    301           this,
    302           shared_change_processor_));
    303 }
    304 
    305 ChangeProcessor* NonUIDataTypeController::GetChangeProcessor() const {
    306   DCHECK_EQ(state_, RUNNING);
    307   return shared_change_processor_->generic_change_processor();
    308 }
    309 
    310 // This method can execute after we've already stopped (and possibly even
    311 // destroyed) both the Syncer and the SyncableService. As a result, all actions
    312 // must either have no side effects outside of the DTC or must be protected
    313 // by |shared_change_processor|, which is guaranteed to have been Disconnected
    314 // if the syncer shut down.
    315 void NonUIDataTypeController::
    316     StartAssociationWithSharedChangeProcessor(
    317         const scoped_refptr<SharedChangeProcessor>& shared_change_processor) {
    318   DCHECK(!ui_thread_->BelongsToCurrentThread());
    319   DCHECK(shared_change_processor.get());
    320   syncer::SyncMergeResult local_merge_result(type());
    321   syncer::SyncMergeResult syncer_merge_result(type());
    322   base::WeakPtrFactory<syncer::SyncMergeResult> weak_ptr_factory(
    323       &syncer_merge_result);
    324 
    325   // Connect |shared_change_processor| to the syncer and get the
    326   // syncer::SyncableService associated with type().
    327   // Note that it's possible the shared_change_processor has already been
    328   // disconnected at this point, so all our accesses to the syncer from this
    329   // point on are through it.
    330   GenericChangeProcessorFactory factory;
    331   local_service_ = shared_change_processor->Connect(
    332       sync_factory_,
    333       &factory,
    334       user_share(),
    335       this,
    336       type(),
    337       weak_ptr_factory.GetWeakPtr());
    338   if (!local_service_.get()) {
    339     syncer::SyncError error(FROM_HERE,
    340                             syncer::SyncError::DATATYPE_ERROR,
    341                             "Failed to connect to syncer.",
    342                             type());
    343     local_merge_result.set_error(error);
    344     StartDone(ASSOCIATION_FAILED,
    345               local_merge_result,
    346               syncer_merge_result);
    347     return;
    348   }
    349 
    350   if (!shared_change_processor->CryptoReadyIfNecessary()) {
    351     StartDone(NEEDS_CRYPTO,
    352               local_merge_result,
    353               syncer_merge_result);
    354     return;
    355   }
    356 
    357   bool sync_has_nodes = false;
    358   if (!shared_change_processor->SyncModelHasUserCreatedNodes(&sync_has_nodes)) {
    359     syncer::SyncError error(FROM_HERE,
    360                             syncer::SyncError::UNRECOVERABLE_ERROR,
    361                             "Failed to load sync nodes",
    362                             type());
    363     local_merge_result.set_error(error);
    364     StartDone(UNRECOVERABLE_ERROR,
    365               local_merge_result,
    366               syncer_merge_result);
    367     return;
    368   }
    369 
    370   base::TimeTicks start_time = base::TimeTicks::Now();
    371   syncer::SyncDataList initial_sync_data;
    372   syncer::SyncError error =
    373       shared_change_processor->GetAllSyncDataReturnError(
    374           type(), &initial_sync_data);
    375   if (error.IsSet()) {
    376     local_merge_result.set_error(error);
    377     StartDone(ASSOCIATION_FAILED,
    378               local_merge_result,
    379               syncer_merge_result);
    380     return;
    381   }
    382 
    383   std::string datatype_context;
    384   if (shared_change_processor->GetDataTypeContext(&datatype_context)) {
    385     local_service_->UpdateDataTypeContext(
    386         type(), syncer::SyncChangeProcessor::NO_REFRESH, datatype_context);
    387   }
    388 
    389   syncer_merge_result.set_num_items_before_association(
    390       initial_sync_data.size());
    391   // Passes a reference to |shared_change_processor|.
    392   local_merge_result =
    393       local_service_->MergeDataAndStartSyncing(
    394           type(),
    395           initial_sync_data,
    396           scoped_ptr<syncer::SyncChangeProcessor>(
    397               new SharedChangeProcessorRef(shared_change_processor)),
    398           scoped_ptr<syncer::SyncErrorFactory>(
    399               new SharedChangeProcessorRef(shared_change_processor)));
    400   RecordAssociationTime(base::TimeTicks::Now() - start_time);
    401   if (local_merge_result.error().IsSet()) {
    402     StartDone(ASSOCIATION_FAILED,
    403               local_merge_result,
    404               syncer_merge_result);
    405     return;
    406   }
    407 
    408   syncer_merge_result.set_num_items_after_association(
    409       shared_change_processor->GetSyncCount());
    410 
    411   StartDone(!sync_has_nodes ? OK_FIRST_RUN : OK,
    412             local_merge_result,
    413             syncer_merge_result);
    414 }
    415 
    416 void NonUIDataTypeController::ClearSharedChangeProcessor() {
    417   DCHECK(ui_thread_->BelongsToCurrentThread());
    418   // |shared_change_processor_| can already be NULL if Stop() is
    419   // called after StartDoneImpl(_, DISABLED, _).
    420   if (shared_change_processor_.get()) {
    421     shared_change_processor_->Disconnect();
    422     shared_change_processor_ = NULL;
    423   }
    424 }
    425 
    426 void NonUIDataTypeController::StopLocalServiceAsync() {
    427   DCHECK(ui_thread_->BelongsToCurrentThread());
    428   PostTaskOnBackendThread(
    429       FROM_HERE,
    430       base::Bind(&NonUIDataTypeController::StopLocalService, this));
    431 }
    432 
    433 void NonUIDataTypeController::StopLocalService() {
    434   DCHECK(!ui_thread_->BelongsToCurrentThread());
    435   if (local_service_.get())
    436     local_service_->StopSyncing(type());
    437   local_service_.reset();
    438 }
    439 
    440 }  // namespace browser_sync
    441