[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>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/feature_list.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
-#include "base/path_service.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/autofill/core/common/autofill_pref_names.h"
 #include "components/browser_sync/browser_sync_switches.h"
 #include "components/history/core/browser/typed_url_data_type_controller.h"
 #include "components/invalidation/impl/invalidation_prefs.h"
 #include "components/invalidation/public/invalidation_service.h"
@@ skipping 111 matching lines @@
 
     // Don't use initial delay unless the last request was an error.
     false,
 };
 
 static const base::FilePath::CharType kSyncDataFolderName[] =
     FILE_PATH_LITERAL("Sync Data");
 static const base::FilePath::CharType kLevelDBFolderName[] =
     FILE_PATH_LITERAL("LevelDB");
 
-#if defined(OS_WIN)
-static const base::FilePath::CharType kLoopbackServerBackendFilename[] =
-    FILE_PATH_LITERAL("profile.pb");
-#endif
-
 namespace {
 
 // Perform the actual sync data folder deletion.
 // This should only be called on the sync thread.
 void DeleteSyncDataFolder(const base::FilePath& directory_path) {
   if (base::DirectoryExists(directory_path)) {
     if (!base::DeleteFile(directory_path, true))
       LOG(DFATAL) << "Could not delete the Sync Data folder.";
   }
 }
 
 }  // namespace
 
 ProfileSyncService::InitParams::InitParams() = default;
 ProfileSyncService::InitParams::~InitParams() = default;
 ProfileSyncService::InitParams::InitParams(InitParams&& other)  // NOLINT
     : sync_client(std::move(other.sync_client)),
       signin_wrapper(std::move(other.signin_wrapper)),
       oauth2_token_service(other.oauth2_token_service),
       gaia_cookie_manager_service(other.gaia_cookie_manager_service),
       start_behavior(other.start_behavior),
       network_time_update_callback(
           std::move(other.network_time_update_callback)),
       base_directory(std::move(other.base_directory)),
       url_request_context(std::move(other.url_request_context)),
       debug_identifier(std::move(other.debug_identifier)),
       channel(other.channel),
-      blocking_pool(other.blocking_pool) {}
+      blocking_pool(other.blocking_pool),
+      local_sync_backend_enabled(other.local_sync_backend_enabled),
+      local_sync_backend_folder(other.local_sync_backend_folder) {}
 
 ProfileSyncService::ProfileSyncService(InitParams init_params)
     : OAuth2TokenService::Consumer("sync"),
       last_auth_error_(AuthError::AuthErrorNone()),
       passphrase_required_reason_(syncer::REASON_PASSPHRASE_NOT_REQUIRED),
       sync_client_(std::move(init_params.sync_client)),
       sync_prefs_(sync_client_->GetPrefService()),
       sync_service_url_(
           syncer::GetSyncServiceURL(*base::CommandLine::ForCurrentProcess(),
                                     init_params.channel)),
       network_time_update_callback_(
           std::move(init_params.network_time_update_callback)),
       base_directory_(init_params.base_directory),
       url_request_context_(init_params.url_request_context),
       debug_identifier_(std::move(init_params.debug_identifier)),
       channel_(init_params.channel),
       blocking_pool_(init_params.blocking_pool),
       is_first_time_sync_configure_(false),
       backend_initialized_(false),
       sync_disabled_by_admin_(false),
       is_auth_in_progress_(false),
+      local_sync_backend_enabled_(init_params.local_sync_backend_enabled),
+      local_sync_backend_folder_(init_params.local_sync_backend_folder),
       signin_(std::move(init_params.signin_wrapper)),
       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),
@@ skipping 24 matching lines @@
 
 ProfileSyncService::~ProfileSyncService() {
   if (gaia_cookie_manager_service_)
     gaia_cookie_manager_service_->RemoveObserver(this);
   sync_prefs_.RemoveSyncPrefObserver(this);
   // Shutdown() should have been called before destruction.
   CHECK(!backend_initialized_);
 }
 
 bool ProfileSyncService::CanSyncStart() const {
-  return IsSyncAllowed() && IsSyncRequested() && IsSignedIn();
+  return (IsSyncAllowed() && IsSyncRequested() &&
+          (local_sync_backend_enabled_ || IsSignedIn()));

[Nicolas Zea, 2016/11/19 00:36:42]

It seems like IsSyncRequested/IsSignedIn/IsSyncAllowed should all return true if
the sync backend is enabled. I worry overriding CanSyncStart but not those will
lead to bugs.

[pastarmovj, 2016/11/22 12:38:08]

I don't think this is the case but I might be misunderstanding something in
which case please correct my reasoning below:

IsSyncRequested is checking whether the prefs::kSyncSuppressStart is not set. I
think this is independent of the sync backend used.

IsSignedIn is technically false in local sync therefore I only ever OR it with
the local sync state.

IsSyncAllowed checks if sync is not disabled e.g. by flag which I believe again
should be respected even in local sync mode. Right now it might seem
counter-intuitive that someone will add both the local sync enabled flag and
disable sync flag but remember that eventually the local sync mode will be
controlled by policy too.

Happy to change something if you believe the reasoning above is wrong or
misguided.

 }
 
 void ProfileSyncService::Initialize() {
   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_,
       base::Bind(&ProfileSyncService::CanBackendStart, base::Unretained(this)),
@@ skipping 45 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 (!local_sync_backend_enabled_ && !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 (!local_sync_backend_enabled_) {
+    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() {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 11 matching lines @@
 
 void ProfileSyncService::RegisterAuthNotifications() {
   oauth2_token_service_->AddObserver(this);
   if (signin())
     signin()->AddObserver(this);
 }
 
 void ProfileSyncService::UnregisterAuthNotifications() {
   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_EQ(data_type_controllers_.count(data_type_controller->type()), 0U);
   data_type_controllers_[data_type_controller->type()] =
       std::move(data_type_controller);
 }
 
 bool ProfileSyncService::IsDataTypeControllerRunning(
@@ skipping 47 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 (local_sync_backend_enabled_)
+    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 15 matching lines @@
     base::Thread::Options options;
     options.timer_slack = base::TIMER_SLACK_MAXIMUM;
     CHECK(sync_thread_->StartWithOptions(options));
   }
 
   SyncCredentials credentials = GetCredentials();
 
   if (delete_stale_data)
     ClearStaleErrors();
 
-  bool enable_local_sync_backend = false;
-  base::FilePath local_sync_backend_folder;
-#if defined(OS_WIN)
-  enable_local_sync_backend = base::CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kEnableLocalSyncBackend);
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kLocalSyncBackendDir)) {
-    local_sync_backend_folder =
-        base::CommandLine::ForCurrentProcess()->GetSwitchValuePath(
-            switches::kLocalSyncBackendDir);
-  } else {
-    // TODO(pastarmovj): Add DIR_ROAMING_USER_DATA to PathService to simplify
-    // this code and move the logic in its right place. See crbug/657810.
-    CHECK(
-        base::PathService::Get(base::DIR_APP_DATA, &local_sync_backend_folder));
-    local_sync_backend_folder =
-        local_sync_backend_folder.Append(FILE_PATH_LITERAL("Chrome/User Data"));
-  }
-  // This code as it is now will assume the same profile order is present on all
-  // machines, which is not a given. It is to be defined if only the Default
-  // profile should get this treatment or all profile as is the case now. The
-  // solution for now will be to assume profiles are created in the same order
-  // on all machines and in the future decide if only the Default one should be
-  // considered roamed.
-  local_sync_backend_folder =
-      local_sync_backend_folder.Append(base_directory_.BaseName());
-  local_sync_backend_folder =
-      local_sync_backend_folder.Append(kLoopbackServerBackendFilename);
-#endif  // defined(OS_WIN)
-
   SyncBackendHost::HttpPostProviderFactoryGetter
       http_post_provider_factory_getter =
           base::Bind(&syncer::NetworkResources::GetHttpPostProviderFactory,
                      base::Unretained(network_resources_.get()),
                      url_request_context_, network_time_update_callback_);
 
   backend_->Initialize(
       this, sync_thread_.get(), GetJsEventHandler(), sync_service_url_,
       local_device_->GetSyncUserAgent(), credentials, delete_stale_data,
-      enable_local_sync_backend, local_sync_backend_folder,
+      local_sync_backend_enabled_, local_sync_backend_folder_,
       base::MakeUnique<syncer::SyncManagerFactory>(),
       MakeWeakHandle(sync_enabled_weak_factory_.GetWeakPtr()),
       base::Bind(syncer::ReportUnrecoverableError, channel_),
       http_post_provider_factory_getter, std::move(saved_nigori_state_));
 }
 
 bool ProfileSyncService::IsEncryptedDatatypeEnabled() const {
   if (encryption_pending())
     return true;
   const syncer::ModelTypeSet preferred_types = GetPreferredDataTypes();
@@ skipping 425 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 (local_sync_backend_enabled_)
+    RequestStart();
 }
 
 void ProfileSyncService::OnBackendInitialized(
     const syncer::WeakHandle<syncer::JsBackend>& js_backend,
     const syncer::WeakHandle<syncer::DataTypeDebugInfoListener>&
         debug_info_listener,
     const std::string& cache_guid,
     bool success) {
   UpdateBackendInitUMA(success);
 
@@ skipping 13 matching lines @@
     OnInternalUnrecoverableError(FROM_HERE, "BackendInitialize failure", false,
                                  ERROR_REASON_BACKEND_INIT_FAILURE);
     return;
   }
 
   backend_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 (local_sync_backend_enabled_) {
+    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_);
 
   PostBackendInitialization();
 }
 
 void ProfileSyncService::OnSyncCycleCompleted() {
   UpdateLastSyncedTime();
@@ skipping 494 matching lines @@
   if (backend_initialized_)
     backend_->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::CanBackendStart() const {
+  if (local_sync_backend_enabled_)
+    return true;
   return CanSyncStart() && oauth2_token_service_ &&
          oauth2_token_service_->RefreshTokenIsAvailable(
              signin_->GetAccountIdToUse());
 }
 
 bool ProfileSyncService::IsBackendInitialized() const {
   return backend_initialized_;
 }
 
 bool ProfileSyncService::ConfigurationDone() const {
@@ skipping 875 matching lines @@
 void ProfileSyncService::OverrideNetworkResourcesForTest(
     std::unique_ptr<syncer::NetworkResources> network_resources) {
   network_resources_ = std::move(network_resources);
 }
 
 bool ProfileSyncService::HasSyncingBackend() const {
   return backend_ != nullptr;
 }
 
 void ProfileSyncService::UpdateFirstSyncTimePref() {
-  if (!IsSignedIn()) {
+  if (!local_sync_backend_enabled_ && !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 {
   // backend_initialized_ implies backend_ isn't null and the manager exists.
   // If sync is not initialized yet, we fail silently.
@@ skipping 83 matching lines @@
 
   DCHECK(startup_controller_->IsSetupInProgress());
   startup_controller_->SetSetupInProgress(false);
 
   if (IsBackendInitialized())
     ReconfigureDatatypeManager();
   NotifyObservers();
 }
 
 }  // namespace browser_sync