[Sync] Remove !frontend_ checks in SBHI.

components/sync/driver/glue/sync_backend_host_impl.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/sync/driver/glue/sync_backend_host_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 510 matching lines @@
       FROM_HERE,
       base::Bind(&SyncBackendHostCore::DoConfigureSyncer, core_, reason,
                  config_types, routing_info, ready_task, retry_callback));
 }
 
 void SyncBackendHostImpl::FinishConfigureDataTypesOnFrontendLoop(
     const ModelTypeSet enabled_types,
     const ModelTypeSet succeeded_configuration_types,
     const ModelTypeSet failed_configuration_types,
     const base::Callback<void(ModelTypeSet, ModelTypeSet)>& ready_task) {
-  if (!frontend_)
-    return;
-
   if (invalidator_) {
     CHECK(invalidator_->UpdateRegisteredInvalidationIds(
         this, ModelTypeSetToObjectIdSet(enabled_types)));
   }
 
   if (!ready_task.is_null())
     ready_task.Run(succeeded_configuration_types, failed_configuration_types);
 }
 
 void SyncBackendHostImpl::AddExperimentalTypes() {
   CHECK(initialized());
   Experiments experiments;
   if (core_->sync_manager()->ReceivedExperiment(&experiments))
     frontend_->OnExperimentsChanged(experiments);
 }
 
 void SyncBackendHostImpl::HandleInitializationSuccessOnFrontendLoop(
     const WeakHandle<JsBackend> js_backend,
     const WeakHandle<DataTypeDebugInfoListener> debug_info_listener,
     std::unique_ptr<ModelTypeConnector> model_type_connector,
     const std::string& cache_guid) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   model_type_connector_ = std::move(model_type_connector);
 
-  if (!frontend_)
-    return;
-
   initialized_ = true;
 
   if (invalidator_) {
     invalidator_->RegisterInvalidationHandler(this);
     invalidation_handler_registered_ = true;
 
     // Fake a state change to initialize the SyncManager's cached invalidator
     // state.
     OnInvalidatorStateChange(invalidator_->GetInvalidatorState());
   }
 
   // Now that we've downloaded the control types, we can see if there are any
   // experimental types to enable. This should be done before we inform
   // the frontend to ensure they're visible in the customize screen.
   AddExperimentalTypes();
   frontend_->OnBackendInitialized(js_backend, debug_info_listener, cache_guid,
                                   true);
 }
 
 void SyncBackendHostImpl::HandleInitializationFailureOnFrontendLoop() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (!frontend_)
-    return;
-
   frontend_->OnBackendInitialized(WeakHandle<JsBackend>(),
                                   WeakHandle<DataTypeDebugInfoListener>(), "",
                                   false);
 }
 
 void SyncBackendHostImpl::HandleSyncCycleCompletedOnFrontendLoop(
     const SyncCycleSnapshot& snapshot) {
-  if (!frontend_)
-    return;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   last_snapshot_ = snapshot;
 
   SDVLOG(1) << "Got snapshot " << snapshot.ToString();
 
   if (!snapshot.poll_finish_time().is_null())
     sync_prefs_->SetLastPollTime(snapshot.poll_finish_time());
 
   // Process any changes to the datatypes we're syncing.
@@ skipping 16 matching lines @@
     BootstrapTokenType token_type) {
   CHECK(sync_prefs_.get());
   if (token_type == PASSPHRASE_BOOTSTRAP_TOKEN)
     sync_prefs_->SetEncryptionBootstrapToken(token);
   else
     sync_prefs_->SetKeystoreEncryptionBootstrapToken(token);
 }
 
 void SyncBackendHostImpl::HandleActionableErrorEventOnFrontendLoop(
     const SyncProtocolError& sync_error) {
-  if (!frontend_)
-    return;
   DCHECK(thread_checker_.CalledOnValidThread());
   frontend_->OnActionableError(sync_error);
 }
 
 void SyncBackendHostImpl::HandleMigrationRequestedOnFrontendLoop(
     ModelTypeSet types) {
-  if (!frontend_)
-    return;
   DCHECK(thread_checker_.CalledOnValidThread());
   frontend_->OnMigrationNeededForTypes(types);
 }
 
 void SyncBackendHostImpl::OnInvalidatorStateChange(InvalidatorState state) {
   sync_task_runner_->PostTask(
       FROM_HERE, base::Bind(&SyncBackendHostCore::DoOnInvalidatorStateChange,
                             core_, state));
 }
 
@@ skipping 16 matching lines @@
   nigori.InitByDerivation("localhost", "dummy", passphrase);
   std::string plaintext;
   bool result = nigori.Decrypt(cached_pending_keys_.blob(), &plaintext);
   DVLOG_IF(1, result) << "Passphrase failed to decrypt pending keys.";
   return result;
 }
 
 void SyncBackendHostImpl::NotifyPassphraseRequired(
     PassphraseRequiredReason reason,
     sync_pb::EncryptedData pending_keys) {
-  if (!frontend_)
-    return;
-
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Update our cache of the cryptographer's pending keys.
   cached_pending_keys_ = pending_keys;
 
   frontend_->OnPassphraseRequired(reason, pending_keys);
 }
 
 void SyncBackendHostImpl::NotifyPassphraseAccepted() {
-  if (!frontend_)
-    return;
-
   DCHECK(thread_checker_.CalledOnValidThread());
-
   // Clear our cache of the cryptographer's pending keys.
   cached_pending_keys_.clear_blob();
   frontend_->OnPassphraseAccepted();
 }
 
 void SyncBackendHostImpl::NotifyEncryptedTypesChanged(
     ModelTypeSet encrypted_types,
     bool encrypt_everything) {
-  if (!frontend_)
-    return;
-
   DCHECK(thread_checker_.CalledOnValidThread());
   frontend_->OnEncryptedTypesChanged(encrypted_types, encrypt_everything);
 }
 
 void SyncBackendHostImpl::NotifyEncryptionComplete() {
-  if (!frontend_)
-    return;
-
   DCHECK(thread_checker_.CalledOnValidThread());
   frontend_->OnEncryptionComplete();
 }
 
 void SyncBackendHostImpl::HandlePassphraseTypeChangedOnFrontendLoop(
     PassphraseType type,
     base::Time explicit_passphrase_time) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(1) << "Passphrase type changed to " << PassphraseTypeToString(type);
   cached_passphrase_type_ = type;
   cached_explicit_passphrase_time_ = explicit_passphrase_time;
 }
 
 void SyncBackendHostImpl::HandleLocalSetPassphraseEncryptionOnFrontendLoop(
     const SyncEncryptionHandler::NigoriState& nigori_state) {
   DCHECK(thread_checker_.CalledOnValidThread());
   frontend_->OnLocalSetPassphraseEncryption(nigori_state);
 }
 
 void SyncBackendHostImpl::HandleConnectionStatusChangeOnFrontendLoop(
     ConnectionStatus status) {
-  if (!frontend_)
-    return;
-
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DVLOG(1) << "Connection status changed: " << ConnectionStatusToString(status);
   frontend_->OnConnectionStatusChange(status);
 }
 
 void SyncBackendHostImpl::HandleProtocolEventOnFrontendLoop(
     std::unique_ptr<ProtocolEvent> event) {
-  if (!frontend_)
-    return;
   frontend_->OnProtocolEvent(*event);
 }
 
 void SyncBackendHostImpl::HandleDirectoryCommitCountersUpdatedOnFrontendLoop(
     ModelType type,
     const CommitCounters& counters) {
-  if (!frontend_)
-    return;
   frontend_->OnDirectoryTypeCommitCounterUpdated(type, counters);
 }
 
 void SyncBackendHostImpl::HandleDirectoryUpdateCountersUpdatedOnFrontendLoop(
     ModelType type,
     const UpdateCounters& counters) {
-  if (!frontend_)
-    return;
   frontend_->OnDirectoryTypeUpdateCounterUpdated(type, counters);
 }
 
 void SyncBackendHostImpl::HandleDirectoryStatusCountersUpdatedOnFrontendLoop(
     ModelType type,
     const StatusCounters& counters) {
-  if (!frontend_)
-    return;
   frontend_->OnDatatypeStatusCounterUpdated(type, counters);
 }
 
 void SyncBackendHostImpl::UpdateInvalidationVersions(
     const std::map<ModelType, int64_t>& invalidation_versions) {
   sync_prefs_->UpdateInvalidationVersions(invalidation_versions);
 }
 
 void SyncBackendHostImpl::RefreshTypesForTest(ModelTypeSet types) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 22 matching lines @@
     const SyncManager::ClearServerDataCallback& frontend_callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   frontend_callback.Run();
 }
 
 }  // namespace syncer
 
 #undef SDVLOG
 
 #undef SLOG