[Sync] Allow sync start without sign-in if the local sync backend is on.

components/browser_sync/profile_sync_service.cc

 // Copyright (c) 2012 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/browser_sync/profile_sync_service.h"
 
 #include <stddef.h>
 
 #include <cstddef>
 #include <map>
@@ skipping 180 matching lines @@
           syncer::GetSyncServiceURL(*base::CommandLine::ForCurrentProcess(),
                                     init_params.channel)),
       network_time_update_callback_(
           std::move(init_params.network_time_update_callback)),
       url_request_context_(init_params.url_request_context),
       blocking_pool_(init_params.blocking_pool),
       is_first_time_sync_configure_(false),
       engine_initialized_(false),
       sync_disabled_by_admin_(false),
       is_auth_in_progress_(false),
+      local_sync_backend_folder_(init_params.local_sync_backend_folder),
       unrecoverable_error_reason_(ERROR_REASON_UNSET),
       expect_sync_configuration_aborted_(false),
       encrypted_types_(syncer::SyncEncryptionHandler::SensitiveTypes()),
       encrypt_everything_allowed_(true),
       encrypt_everything_(false),
       encryption_pending_(false),
       configure_status_(DataTypeManager::UNKNOWN),
       oauth2_token_service_(init_params.oauth2_token_service),
       request_access_token_backoff_(&kRequestAccessTokenBackoffPolicy),
       connection_status_(syncer::CONNECTION_NOT_ATTEMPTED),
@@ skipping 23 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   if (gaia_cookie_manager_service_)
     gaia_cookie_manager_service_->RemoveObserver(this);
   sync_prefs_.RemoveSyncPrefObserver(this);
   // Shutdown() should have been called before destruction.
   CHECK(!engine_initialized_);
 }
 
 bool ProfileSyncService::CanSyncStart() const {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return IsSyncAllowed() && IsSyncRequested() && IsSignedIn();
+  return (IsSyncAllowed() && IsSyncRequested() &&
+          (IsLocalSyncEnabled() || IsSignedIn()));
 }
 
 void ProfileSyncService::Initialize() {
   DCHECK(thread_checker_.CalledOnValidThread());
   sync_client_->Initialize();
 
   // We don't pass StartupController an Unretained reference to future-proof
   // against the controller impl changing to post tasks.
   startup_controller_ = base::MakeUnique<syncer::StartupController>(
       &sync_prefs_,
@@ skipping 46 matching lines @@
     gaia_cookie_manager_service_->AddObserver(this);
 
   // We clear this here (vs Shutdown) because we want to remember that an error
   // happened on shutdown so we can display details (message, location) about it
   // in about:sync.
   ClearStaleErrors();
 
   sync_prefs_.AddSyncPrefObserver(this);
 
   SyncInitialState sync_state = CAN_START;
-  if (!IsSignedIn()) {
+  if (!IsLocalSyncEnabled() && !IsSignedIn()) {
     sync_state = NOT_SIGNED_IN;
   } else if (IsManaged()) {
     sync_state = IS_MANAGED;
   } else if (!IsSyncAllowedByPlatform()) {
     // This case should currently never be hit, as Android's master sync isn't
     // plumbed into PSS until after this function. See http://crbug.com/568771.
     sync_state = NOT_ALLOWED_BY_PLATFORM;
   } else if (!IsSyncRequested()) {
     if (IsFirstSetupComplete()) {
       sync_state = NOT_REQUESTED;
     } else {
       sync_state = NOT_REQUESTED_NOT_SETUP;
     }
   } else if (!IsFirstSetupComplete()) {
     sync_state = NEEDS_CONFIRMATION;
   }
   UMA_HISTOGRAM_ENUMERATION("Sync.InitialState", sync_state,
                             SYNC_INITIAL_STATE_LIMIT);
 
   // If sync isn't allowed, the only thing to do is to turn it off.
   if (!IsSyncAllowed()) {
     // Only clear data if disallowed by policy.
     RequestStop(IsManaged() ? CLEAR_DATA : KEEP_DATA);
     return;
   }
 
-  RegisterAuthNotifications();
+  if (!IsLocalSyncEnabled()) {
+    RegisterAuthNotifications();
 
-  if (!IsSignedIn()) {
-    // Clean up in case of previous crash during signout.
-    StopImpl(CLEAR_DATA);
+    if (!IsSignedIn()) {
+      // Clean up in case of previous crash during signout.
+      StopImpl(CLEAR_DATA);
+    }
   }
 
 #if defined(OS_CHROMEOS)
   std::string bootstrap_token = sync_prefs_.GetEncryptionBootstrapToken();
   if (bootstrap_token.empty()) {
     sync_prefs_.SetEncryptionBootstrapToken(
         sync_prefs_.GetSpareBootstrapToken());
   }
 #endif
 
 #if !defined(OS_ANDROID)
   DCHECK(sync_error_controller_ == nullptr)
       << "Initialize() called more than once.";
   sync_error_controller_ = base::MakeUnique<syncer::SyncErrorController>(this);
   AddObserver(sync_error_controller_.get());
 #endif
 
   memory_pressure_listener_ = base::MakeUnique<base::MemoryPressureListener>(
       base::Bind(&ProfileSyncService::OnMemoryPressure,
                  sync_enabled_weak_factory_.GetWeakPtr()));
   startup_controller_->Reset(GetRegisteredDataTypes());
 
-  // Auto-start means means the first time the profile starts up, sync should
-  // start up immediately.
+  // Auto-start means the first time the profile starts up, sync should start up
+  // immediately.
   if (start_behavior_ == AUTO_START && IsSyncRequested() &&
       !IsFirstSetupComplete()) {
     startup_controller_->TryStartImmediately();
   } else {
     startup_controller_->TryStart();
   }
 }
 
 void ProfileSyncService::StartSyncingWithServer() {
   if (base::FeatureList::IsEnabled(
@@ skipping 15 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   oauth2_token_service_->AddObserver(this);
   if (signin())
     signin()->AddObserver(this);
 }
 
 void ProfileSyncService::UnregisterAuthNotifications() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (signin())
     signin()->RemoveObserver(this);
-  oauth2_token_service_->RemoveObserver(this);
+  if (oauth2_token_service_)
+    oauth2_token_service_->RemoveObserver(this);
 }
 
 void ProfileSyncService::RegisterDataTypeController(
     std::unique_ptr<syncer::DataTypeController> data_type_controller) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(data_type_controllers_.count(data_type_controller->type()), 0U);
   data_type_controllers_[data_type_controller->type()] =
       std::move(data_type_controller);
 }
 
@@ skipping 55 matching lines @@
     return;
   }
   DCHECK(iter->second);
 
   static_cast<sync_sessions::SessionDataTypeController*>(iter->second.get())
       ->OnSessionRestoreComplete();
 }
 
 SyncCredentials ProfileSyncService::GetCredentials() {
   SyncCredentials credentials;
+
+  // No credentials exist or are needed for the local sync backend.
+  if (IsLocalSyncEnabled())
+    return credentials;
+
   credentials.account_id = signin_->GetAccountIdToUse();
   DCHECK(!credentials.account_id.empty());
   credentials.email = signin_->GetEffectiveUsername();
   credentials.sync_token = access_token_;
 
   if (credentials.sync_token.empty())
     credentials.sync_token = "credentials_lost";
 
   credentials.scope_set.insert(signin_->GetSyncScopeToUse());
 
@@ skipping 454 matching lines @@
     OnInternalUnrecoverableError(FROM_HERE, "BackendInitialize failure", false,
                                  ERROR_REASON_ENGINE_INIT_FAILURE);
     return;
   }
 
   engine_initialized_ = true;
 
   sync_js_controller_.AttachJsBackend(js_backend);
   debug_info_listener_ = debug_info_listener;
 
-  SigninClient* signin_client = signin_->GetOriginal()->signin_client();
-  DCHECK(signin_client);
-  std::string signin_scoped_device_id =
-      signin_client->GetSigninScopedDeviceId();
+  std::string signin_scoped_device_id;
+  if (IsLocalSyncEnabled()) {
+    signin_scoped_device_id = "local_device";
+  } else {
+    SigninClient* signin_client = signin_->GetOriginal()->signin_client();
+    DCHECK(signin_client);
+    std::string signin_scoped_device_id =
+        signin_client->GetSigninScopedDeviceId();
+  }
 
   // Initialize local device info.
   local_device_->Initialize(cache_guid, signin_scoped_device_id,
                             blocking_pool_);
 
   if (protocol_event_observers_.might_have_observers()) {
     engine_->RequestBufferedProtocolEventsAndEnableForwarding();
   }
 
   if (type_debug_info_observers_.might_have_observers()) {
@@ skipping 29 matching lines @@
   std::vector<gaia::ListedAccount> accounts;
   std::vector<gaia::ListedAccount> signed_out_accounts;
   GoogleServiceAuthError error(GoogleServiceAuthError::NONE);
   if (gaia_cookie_manager_service_ &&
       gaia_cookie_manager_service_->ListAccounts(
           &accounts, &signed_out_accounts, "ChromiumProfileSyncService")) {
     OnGaiaAccountsInCookieUpdated(accounts, signed_out_accounts, error);
   }
 
   NotifyObservers();
+
+  // Nobody will call us to start if no sign in is going to happen.
+  if (IsLocalSyncEnabled())
+    RequestStart();
 }
 
 void ProfileSyncService::OnSyncCycleCompleted() {
   DCHECK(thread_checker_.CalledOnValidThread());
   UpdateLastSyncedTime();
   const syncer::SyncCycleSnapshot snapshot = GetLastCycleSnapshot();
   if (IsDataTypeControllerRunning(syncer::SESSIONS) &&
       snapshot.model_neutral_state().get_updates_request_types.Has(
           syncer::SESSIONS) &&
       !syncer::HasSyncerError(snapshot.model_neutral_state())) {
@@ skipping 508 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   return IsSyncAllowedByFlag() && !IsManaged() && IsSyncAllowedByPlatform();
 }
 
 bool ProfileSyncService::IsSyncActive() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return engine_initialized_ && data_type_manager_ &&
          data_type_manager_->state() != DataTypeManager::STOPPED;
 }
 
+bool ProfileSyncService::IsLocalSyncEnabled() const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  return sync_prefs_.IsLocalSyncEnabled();
+}
+
 void ProfileSyncService::TriggerRefresh(const syncer::ModelTypeSet& types) {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (engine_initialized_)
     engine_->TriggerRefresh(types);
 }
 
 bool ProfileSyncService::IsSignedIn() const {
   // Sync is logged in if there is a non-empty effective account id.
   return !signin_->GetAccountIdToUse().empty();
 }
 
 bool ProfileSyncService::CanEngineStart() const {
+  if (IsLocalSyncEnabled())
+    return true;
   return CanSyncStart() && oauth2_token_service_ &&
          oauth2_token_service_->RefreshTokenIsAvailable(
              signin_->GetAccountIdToUse());
 }
 
 bool ProfileSyncService::IsEngineInitialized() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return engine_initialized_;
 }
 
@@ skipping 936 matching lines @@
     std::unique_ptr<syncer::NetworkResources> network_resources) {
   DCHECK(thread_checker_.CalledOnValidThread());
   network_resources_ = std::move(network_resources);
 }
 
 bool ProfileSyncService::HasSyncingEngine() const {
   return engine_ != nullptr;
 }
 
 void ProfileSyncService::UpdateFirstSyncTimePref() {
-  if (!IsSignedIn()) {
+  if (!IsLocalSyncEnabled() && !IsSignedIn()) {
     sync_prefs_.ClearFirstSyncTime();
   } else if (sync_prefs_.GetFirstSyncTime().is_null()) {
     // Set if not set before and it's syncing now.
     sync_prefs_.SetFirstSyncTime(base::Time::Now());
   }
 }
 
 void ProfileSyncService::FlushDirectory() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   // engine_initialized_ implies engine_ isn't null and the manager exists.
@@ skipping 90 matching lines @@
 
   DCHECK(startup_controller_->IsSetupInProgress());
   startup_controller_->SetSetupInProgress(false);
 
   if (IsEngineInitialized())
     ReconfigureDatatypeManager();
   NotifyObservers();
 }
 
 }  // namespace browser_sync