📰 The Status card reports disabled sync states

components/ntp_snippets/ntp_snippets_service.cc

 // Copyright 2015 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/ntp_snippets/ntp_snippets_service.h"
 
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner_util.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/image_fetcher/image_fetcher.h"
 #include "components/ntp_snippets/ntp_snippets_constants.h"
 #include "components/ntp_snippets/ntp_snippets_database.h"
 #include "components/ntp_snippets/pref_names.h"
 #include "components/ntp_snippets/switches.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
+#include "components/signin/core/browser/signin_manager.h"
 #include "components/suggestions/proto/suggestions.pb.h"
 #include "components/sync_driver/sync_service.h"
 #include "components/variations/variations_associated_data.h"
 #include "ui/gfx/image/image.h"
 
 using image_fetcher::ImageFetcher;
 using suggestions::ChromeSuggestion;
 using suggestions::SuggestionsProfile;
 using suggestions::SuggestionsService;
 
@@ skipping 134 matching lines @@
           snippets->begin(), snippets->end(),
           [](const std::unique_ptr<NTPSnippet>& snippet) { return !snippet; }),
       snippets->end());
 }
 
 }  // namespace
 
 NTPSnippetsService::NTPSnippetsService(
     bool enabled,
     PrefService* pref_service,
+    SigninManagerBase* signin_manager,
     sync_driver::SyncService* sync_service,
     SuggestionsService* suggestions_service,
     const std::string& application_language_code,
     NTPSnippetsScheduler* scheduler,
     std::unique_ptr<NTPSnippetsFetcher> snippets_fetcher,
     std::unique_ptr<ImageFetcher> image_fetcher,
     std::unique_ptr<NTPSnippetsDatabase> database)
     : state_(State::NOT_INITED),
-      explicitly_disabled_(!enabled),
+      disabled_reason_(enabled ? DisabledReason::NONE
+                               : DisabledReason::EXPLICITLY_DISABLED),
       pref_service_(pref_service),
+      signin_manager_(signin_manager),
       sync_service_(sync_service),
       sync_service_observer_(this),
       suggestions_service_(suggestions_service),
       application_language_code_(application_language_code),
       scheduler_(scheduler),
       snippets_fetcher_(std::move(snippets_fetcher)),
       image_fetcher_(std::move(image_fetcher)),
       database_(std::move(database)),
       fetch_after_load_(false) {
   // TODO(dgn) should be removed after branch point (https:://crbug.com/617585).
   ClearDeprecatedPrefs();
 
-  if (explicitly_disabled_) {
+  if (disabled_reason_ == DisabledReason::EXPLICITLY_DISABLED) {
+    // Don't even bother loading the database.
     EnterState(State::DISABLED);
     return;
   }
 
   // We transition to other states while finalizing the initialization, when the
   // database is done loading.
   database_->Load(base::Bind(&NTPSnippetsService::OnDatabaseLoaded,
                              base::Unretained(this)));
 }
 
@@ skipping 120 matching lines @@
 }
 
 void NTPSnippetsService::AddObserver(NTPSnippetsServiceObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void NTPSnippetsService::RemoveObserver(NTPSnippetsServiceObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
-DisabledReason NTPSnippetsService::GetDisabledReason() const {
-  if (explicitly_disabled_)
-    return DisabledReason::EXPLICITLY_DISABLED;
-
-  if (!sync_service_ || !sync_service_->CanSyncStart()) {
-    DVLOG(1) << "[GetDisabledReason] Sync disabled";
-    return DisabledReason::HISTORY_SYNC_DISABLED;
-  }
-
-  // !IsSyncActive in cases where CanSyncStart is true hints at the backend not
-  // being initialized.
-  // ConfigurationDone() verifies that the sync service has properly loaded its
-  // configuration and is aware of the different data types to sync.
-  if (!sync_service_->IsSyncActive() || !sync_service_->ConfigurationDone()) {
-    DVLOG(1) << "[GetDisabledReason] Sync initialization is not complete.";
-    return DisabledReason::HISTORY_SYNC_STATE_UNKNOWN;
-  }
-
-  if (!sync_service_->GetActiveDataTypes().Has(
-          syncer::HISTORY_DELETE_DIRECTIVES)) {
-    DVLOG(1) << "[GetDisabledReason] History sync disabled";
-    return DisabledReason::HISTORY_SYNC_DISABLED;
-  }
-
-  DVLOG(1) << "[GetDisabledReason] Enabled";
-  return DisabledReason::NONE;
-}
-
 // static
 int NTPSnippetsService::GetMaxSnippetCountForTesting() {
   return kMaxSnippetCount;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Private methods
 
 void NTPSnippetsService::OnStateChanged() {
   if (state_ == State::SHUT_DOWN)
@@ skipping 233 matching lines @@
 }
 
 void NTPSnippetsService::EnterStateDisabled() {
   ClearSnippets();
   ClearDiscardedSnippets();
 
   suggestions_service_subscription_.reset();
   expiry_timer_.Stop();
 
   RescheduleFetching();
-  FOR_EACH_OBSERVER(NTPSnippetsServiceObserver, observers_,
-                    NTPSnippetsServiceDisabled());
 }
 
 void NTPSnippetsService::EnterStateShutdown() {
   FOR_EACH_OBSERVER(NTPSnippetsServiceObserver, observers_,
                     NTPSnippetsServiceShutdown());
 
   expiry_timer_.Stop();
   suggestions_service_subscription_.reset();
 
-  if (sync_service_)
+  // When explicity disabled we don't register the observer.
+  if (sync_service_ && disabled_reason_ != DisabledReason::EXPLICITLY_DISABLED)
     sync_service_observer_.Remove(sync_service_);
 }
 
 void NTPSnippetsService::FinishInitialization() {
   snippets_fetcher_->SetCallback(
       base::Bind(&NTPSnippetsService::OnFetchFinished, base::Unretained(this)));
 
   // |sync_service_| can be null in tests or if sync is disabled.
   // This is a service we want to keep listening to all the time, independently
   // from the state, since it will allow us to enable or disable the snippets
   // service.
   if (sync_service_)
     sync_service_observer_.Add(sync_service_);
 
   // Change state after we started loading the snippets. During startup, the
   // Sync service might not be completely loaded when we initialize this
   // service, so we might stay in the NOT_INITED state until the sync state is
   // updated. See |GetStateForDependenciesStatus|.
   EnterState(GetStateForDependenciesStatus());
 
   FOR_EACH_OBSERVER(NTPSnippetsServiceObserver, observers_,
                     NTPSnippetsServiceLoaded());
+}
 
-  // Start a fetch if we don't have any snippets yet, or a fetch was requested
-  // earlier.
-  if (ready() && (snippets_.empty() || fetch_after_load_)) {
-    fetch_after_load_ = false;
-    FetchSnippets();
+void NTPSnippetsService::UpdateDisabledReason() {
+  DisabledReason new_disabled_reason = GetNewDisabledReason();
+
+  if (new_disabled_reason == disabled_reason_)
+    return;
+
+  disabled_reason_ = new_disabled_reason;
+  FOR_EACH_OBSERVER(NTPSnippetsServiceObserver, observers_,
+                    NTPSnippetsServiceDisabledReasonChanged(disabled_reason_));
+}
+
+DisabledReason NTPSnippetsService::GetNewDisabledReason() const {
+  if (disabled_reason_ == DisabledReason::EXPLICITLY_DISABLED) {
+    DVLOG(1) << "[GetNewDisabledReason] Explicitly disabled";
+    return DisabledReason::EXPLICITLY_DISABLED;
   }
+
+  if (!signin_manager_ || !signin_manager_->IsAuthenticated()) {
+    DVLOG(1) << "[GetNewDisabledReason] Signed out";
+    return DisabledReason::SIGNED_OUT;
+  }
+
+  if (!sync_service_ || !sync_service_->CanSyncStart()) {
+    DVLOG(1) << "[GetNewDisabledReason] Sync disabled";
+    return DisabledReason::SYNC_DISABLED;
+  }
+
+  // !IsSyncActive in cases where CanSyncStart is true hints at the backend not
+  // being initialized.
+  // ConfigurationDone() verifies that the sync service has properly loaded its
+  // configuration and is aware of the different data types to sync.
+  if (!sync_service_->IsSyncActive() || !sync_service_->ConfigurationDone()) {
+    DVLOG(1) << "[GetNewDisabledReason] Sync initialization is not complete.";
+    return DisabledReason::HISTORY_SYNC_STATE_UNKNOWN;
+  }
+
+  if (sync_service_->IsEncryptEverythingEnabled()) {
+    DVLOG(1) << "[GetNewDisabledReason] Encryption is enabled";
+    return DisabledReason::PASSPHRASE_ENCRYPTION_ENABLED;
+  }
+
+  if (!sync_service_->GetActiveDataTypes().Has(
+          syncer::HISTORY_DELETE_DIRECTIVES)) {
+    DVLOG(1) << "[GetNewDisabledReason] History sync disabled";
+    return DisabledReason::HISTORY_SYNC_DISABLED;
+  }
+
+  DVLOG(1) << "[GetNewDisabledReason] Enabled";
+  return DisabledReason::NONE;
 }
 
 NTPSnippetsService::State NTPSnippetsService::GetStateForDependenciesStatus() {
-  switch (GetDisabledReason()) {
+  UpdateDisabledReason();
+  switch (disabled_reason_) {
     case DisabledReason::NONE:
       return State::READY;
 
     case DisabledReason::HISTORY_SYNC_STATE_UNKNOWN:
       // HistorySync is not initialized yet, so we don't know what the actual
       // state is and we just return the current one. If things change,
       // |OnStateChanged| will call this function again to update the state.
       DVLOG(1) << "Sync configuration incomplete, continuing based on the "
-             "current state.";
+                  "current state.";
       return state_;
 
     case DisabledReason::EXPLICITLY_DISABLED:
+    case DisabledReason::SIGNED_OUT:
+    case DisabledReason::SYNC_DISABLED:
+    case DisabledReason::PASSPHRASE_ENCRYPTION_ENABLED:
     case DisabledReason::HISTORY_SYNC_DISABLED:
       return State::DISABLED;
   }
 
   // All cases should be handled by the above switch
   NOTREACHED();
   return State::DISABLED;
 }
 
 void NTPSnippetsService::EnterState(State state) {
   if (state == state_)
     return;
 
   switch (state) {
     case State::NOT_INITED:
       // Initial state, it should not be possible to get back there.
       NOTREACHED();
       return;
 
     case State::READY: {
       DCHECK(state_ == State::NOT_INITED || state_ == State::DISABLED);
 
-      // If the service was previously disabled, we will need to start a fetch
-      // because otherwise there won't be any.
-      bool fetch_snippets = state_ == State::DISABLED || fetch_after_load_;
+      bool fetch_snippets = snippets_.empty() || fetch_after_load_;
       DVLOG(1) << "Entering state: READY";
       state_ = State::READY;
       fetch_after_load_ = false;
       EnterStateEnabled(fetch_snippets);
       return;
     }
 
     case State::DISABLED:
       DCHECK(state_ == State::NOT_INITED || state_ == State::READY);
 
       DVLOG(1) << "Entering state: DISABLED";
       state_ = State::DISABLED;
       EnterStateDisabled();
       return;
 
     case State::SHUT_DOWN:
       DVLOG(1) << "Entering state: SHUT_DOWN";
       state_ = State::SHUT_DOWN;
       EnterStateShutdown();
       return;
   }
 }
 
 void NTPSnippetsService::ClearDeprecatedPrefs() {
   pref_service_->ClearPref(prefs::kDeprecatedSnippets);
   pref_service_->ClearPref(prefs::kDeprecatedDiscardedSnippets);
 }
 
 }  // namespace ntp_snippets