Index: components/browser_sync/browser/profile_sync_service.cc |
diff --git a/components/browser_sync/browser/profile_sync_service.cc b/components/browser_sync/browser/profile_sync_service.cc |
deleted file mode 100644 |
index ef326ebbd80908f60ee6ff264413627d8d1260b6..0000000000000000000000000000000000000000 |
--- a/components/browser_sync/browser/profile_sync_service.cc |
+++ /dev/null |
@@ -1,2538 +0,0 @@ |
-// 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/browser/profile_sync_service.h" |
- |
-#include <stddef.h> |
- |
-#include <cstddef> |
-#include <map> |
-#include <utility> |
-#include <vector> |
- |
-#include "base/bind.h" |
-#include "base/bind_helpers.h" |
-#include "base/callback.h" |
-#include "base/command_line.h" |
-#include "base/compiler_specific.h" |
-#include "base/feature_list.h" |
-#include "base/files/file_util.h" |
-#include "base/logging.h" |
-#include "base/macros.h" |
-#include "base/memory/ptr_util.h" |
-#include "base/memory/ref_counted.h" |
-#include "base/metrics/histogram.h" |
-#include "base/profiler/scoped_tracker.h" |
-#include "base/single_thread_task_runner.h" |
-#include "base/strings/string16.h" |
-#include "base/strings/stringprintf.h" |
-#include "base/threading/thread_restrictions.h" |
-#include "base/threading/thread_task_runner_handle.h" |
-#include "base/time/time.h" |
-#include "build/build_config.h" |
-#include "components/autofill/core/common/autofill_pref_names.h" |
-#include "components/browser_sync/common/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" |
-#include "components/pref_registry/pref_registry_syncable.h" |
-#include "components/prefs/json_pref_store.h" |
-#include "components/signin/core/browser/about_signin_internals.h" |
-#include "components/signin/core/browser/profile_oauth2_token_service.h" |
-#include "components/signin/core/browser/signin_manager.h" |
-#include "components/signin/core/browser/signin_metrics.h" |
-#include "components/strings/grit/components_strings.h" |
-#include "components/sync/api/model_type_store.h" |
-#include "components/sync/api/sync_error.h" |
-#include "components/sync/base/cryptographer.h" |
-#include "components/sync/base/experiments.h" |
-#include "components/sync/base/passphrase_type.h" |
-#include "components/sync/base/stop_source.h" |
-#include "components/sync/base/sync_db_util.h" |
-#include "components/sync/core/configure_reason.h" |
-#include "components/sync/core/http_bridge_network_resources.h" |
-#include "components/sync/core/network_resources.h" |
-#include "components/sync/core/shared_model_type_processor.h" |
-#include "components/sync/core/shutdown_reason.h" |
-#include "components/sync/core/sync_encryption_handler.h" |
-#include "components/sync/device_info/device_info.h" |
-#include "components/sync/device_info/device_info_service.h" |
-#include "components/sync/device_info/device_info_sync_service.h" |
-#include "components/sync/device_info/device_info_tracker.h" |
-#include "components/sync/driver/backend_migrator.h" |
-#include "components/sync/driver/change_processor.h" |
-#include "components/sync/driver/data_type_controller.h" |
-#include "components/sync/driver/directory_data_type_controller.h" |
-#include "components/sync/driver/glue/chrome_report_unrecoverable_error.h" |
-#include "components/sync/driver/glue/sync_backend_host.h" |
-#include "components/sync/driver/glue/sync_backend_host_impl.h" |
-#include "components/sync/driver/pref_names.h" |
-#include "components/sync/driver/signin_manager_wrapper.h" |
-#include "components/sync/driver/sync_api_component_factory.h" |
-#include "components/sync/driver/sync_client.h" |
-#include "components/sync/driver/sync_driver_switches.h" |
-#include "components/sync/driver/sync_error_controller.h" |
-#include "components/sync/driver/sync_stopped_reporter.h" |
-#include "components/sync/driver/sync_type_preference_provider.h" |
-#include "components/sync/driver/sync_util.h" |
-#include "components/sync/driver/system_encryptor.h" |
-#include "components/sync/driver/user_selectable_sync_type.h" |
-#include "components/sync/engine/cycle/model_neutral_state.h" |
-#include "components/sync/engine/cycle/type_debug_info_observer.h" |
-#include "components/sync/engine/sync_string_conversions.h" |
-#include "components/sync/js/js_event_details.h" |
-#include "components/sync/protocol/sync.pb.h" |
-#include "components/sync/syncable/directory.h" |
-#include "components/sync/syncable/syncable_read_transaction.h" |
-#include "components/sync_sessions/favicon_cache.h" |
-#include "components/sync_sessions/session_data_type_controller.h" |
-#include "components/sync_sessions/sessions_sync_manager.h" |
-#include "components/sync_sessions/sync_sessions_client.h" |
-#include "components/syncable_prefs/pref_service_syncable.h" |
-#include "components/version_info/version_info_values.h" |
-#include "net/cookies/cookie_monster.h" |
-#include "net/url_request/url_request_context_getter.h" |
-#include "ui/base/l10n/l10n_util.h" |
-#include "ui/base/l10n/time_format.h" |
- |
-#if defined(OS_ANDROID) |
-#include "components/sync/core/read_transaction.h" |
-#endif |
- |
-using browser_sync::SyncBackendHost; |
-using sync_driver::ChangeProcessor; |
-using sync_driver::DataTypeController; |
-using sync_driver::DataTypeManager; |
-using sync_driver::DataTypeStatusTable; |
-using sync_driver::DeviceInfoSyncService; |
-using sync_driver_v2::DeviceInfoService; |
-using sync_sessions::SessionsSyncManager; |
-using syncer::ModelType; |
-using syncer::ModelTypeSet; |
-using syncer::JsBackend; |
-using syncer::JsController; |
-using syncer::JsEventDetails; |
-using syncer::JsEventHandler; |
-using syncer::ModelSafeRoutingInfo; |
-using syncer::SyncCredentials; |
-using syncer::SyncProtocolError; |
-using syncer::WeakHandle; |
-using syncer_v2::ModelTypeStore; |
-using syncer_v2::SharedModelTypeProcessor; |
- |
-typedef GoogleServiceAuthError AuthError; |
- |
-const char kSyncUnrecoverableErrorHistogram[] = |
- "Sync.UnrecoverableErrors"; |
- |
-const net::BackoffEntry::Policy kRequestAccessTokenBackoffPolicy = { |
- // Number of initial errors (in sequence) to ignore before applying |
- // exponential back-off rules. |
- 0, |
- |
- // Initial delay for exponential back-off in ms. |
- 2000, |
- |
- // Factor by which the waiting time will be multiplied. |
- 2, |
- |
- // Fuzzing percentage. ex: 10% will spread requests randomly |
- // between 90%-100% of the calculated time. |
- 0.2, // 20% |
- |
- // Maximum amount of time we are willing to delay our request in ms. |
- // TODO(pavely): crbug.com/246686 ProfileSyncService should retry |
- // RequestAccessToken on connection state change after backoff |
- 1000 * 3600 * 4, // 4 hours. |
- |
- // Time to keep an entry from being discarded even when it |
- // has no significant state, -1 to never discard. |
- -1, |
- |
- // 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"); |
- |
-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 |
- |
-bool ShouldShowActionOnUI( |
- const syncer::SyncProtocolError& error) { |
- return (error.action != syncer::UNKNOWN_ACTION && |
- error.action != syncer::DISABLE_SYNC_ON_CLIENT && |
- error.action != syncer::STOP_SYNC_FOR_DISABLED_ACCOUNT && |
- error.action != syncer::RESET_LOCAL_SYNC_DATA); |
-} |
- |
-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), |
- db_thread(std::move(other.db_thread)), |
- file_thread(std::move(other.file_thread)), |
- blocking_pool(other.blocking_pool) {} |
- |
-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_( |
- 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), |
- db_thread_(init_params.db_thread), |
- file_thread_(init_params.file_thread), |
- 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), |
- 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), |
- connection_status_(syncer::CONNECTION_NOT_ATTEMPTED), |
- last_get_token_error_(GoogleServiceAuthError::AuthErrorNone()), |
- gaia_cookie_manager_service_(init_params.gaia_cookie_manager_service), |
- network_resources_(new syncer::HttpBridgeNetworkResources), |
- start_behavior_(init_params.start_behavior), |
- directory_path_( |
- base_directory_.Append(base::FilePath(kSyncDataFolderName))), |
- catch_up_configure_in_progress_(false), |
- passphrase_prompt_triggered_by_version_(false), |
- sync_enabled_weak_factory_(this), |
- weak_factory_(this) { |
- DCHECK(thread_checker_.CalledOnValidThread()); |
- DCHECK(sync_client_); |
- std::string last_version = sync_prefs_.GetLastRunVersion(); |
- std::string current_version = PRODUCT_VERSION; |
- sync_prefs_.SetLastRunVersion(current_version); |
- |
- // Check for a major version change. Note that the versions have format |
- // MAJOR.MINOR.BUILD.PATCH. |
- if (last_version.substr(0, last_version.find('.')) != |
- current_version.substr(0, current_version.find('.'))) { |
- passphrase_prompt_triggered_by_version_ = true; |
- } |
-} |
- |
-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(); |
-} |
- |
-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_.reset(new browser_sync::StartupController( |
- &sync_prefs_, |
- base::Bind(&ProfileSyncService::CanBackendStart, base::Unretained(this)), |
- base::Bind(&ProfileSyncService::StartUpSlowBackendComponents, |
- weak_factory_.GetWeakPtr()))); |
- std::unique_ptr<sync_sessions::LocalSessionEventRouter> router( |
- sync_client_->GetSyncSessionsClient()->GetLocalSessionEventRouter()); |
- local_device_ = sync_client_->GetSyncApiComponentFactory() |
- ->CreateLocalDeviceInfoProvider(); |
- sync_stopped_reporter_.reset(new browser_sync::SyncStoppedReporter( |
- sync_service_url_, local_device_->GetSyncUserAgent(), |
- url_request_context_, |
- browser_sync::SyncStoppedReporter::ResultCallback())); |
- sessions_sync_manager_.reset(new SessionsSyncManager( |
- sync_client_->GetSyncSessionsClient(), &sync_prefs_, local_device_.get(), |
- std::move(router), |
- base::Bind(&ProfileSyncService::NotifyForeignSessionUpdated, |
- sync_enabled_weak_factory_.GetWeakPtr()), |
- base::Bind(&ProfileSyncService::TriggerRefresh, |
- sync_enabled_weak_factory_.GetWeakPtr(), |
- syncer::ModelTypeSet(syncer::SESSIONS)))); |
- |
- if (base::FeatureList::IsEnabled(switches::kSyncUSSDeviceInfo)) { |
- scoped_refptr<base::SequencedTaskRunner> blocking_task_runner( |
- blocking_pool_->GetSequencedTaskRunnerWithShutdownBehavior( |
- blocking_pool_->GetSequenceToken(), |
- base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)); |
- // TODO(skym): Stop creating leveldb files when signed out. |
- // TODO(skym): Verify using AsUTF8Unsafe is okay here. Should work as long |
- // as the Local State file is guaranteed to be UTF-8. |
- device_info_service_.reset(new DeviceInfoService( |
- local_device_.get(), |
- base::Bind(&ModelTypeStore::CreateStore, syncer::DEVICE_INFO, |
- directory_path_.Append(base::FilePath(kLevelDBFolderName)) |
- .AsUTF8Unsafe(), |
- blocking_task_runner), |
- base::Bind(&SharedModelTypeProcessor::CreateAsChangeProcessor))); |
- } else { |
- device_info_sync_service_.reset( |
- new DeviceInfoSyncService(local_device_.get())); |
- } |
- |
- sync_driver::SyncApiComponentFactory::RegisterDataTypesMethod |
- register_platform_types_callback = |
- sync_client_->GetRegisterPlatformTypesCallback(); |
- sync_client_->GetSyncApiComponentFactory()->RegisterDataTypes( |
- this, register_platform_types_callback); |
- |
- if (gaia_cookie_manager_service_) |
- 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()) { |
- 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 (!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_ == NULL) |
- << "Initialize() called more than once."; |
- sync_error_controller_.reset(new SyncErrorController(this)); |
- AddObserver(sync_error_controller_.get()); |
-#endif |
- |
- memory_pressure_listener_.reset(new 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. |
- if (start_behavior_ == AUTO_START && IsSyncRequested() && |
- !IsFirstSetupComplete()) { |
- startup_controller_->TryStartImmediately(); |
- } else { |
- startup_controller_->TryStart(); |
- } |
-} |
- |
-void ProfileSyncService::StartSyncingWithServer() { |
- DCHECK(thread_checker_.CalledOnValidThread()); |
- |
- if (base::FeatureList::IsEnabled( |
- switches::kSyncClearDataOnPassphraseEncryption) && |
- sync_prefs_.GetPassphraseEncryptionTransitionInProgress()) { |
- BeginConfigureCatchUpBeforeClear(); |
- return; |
- } |
- |
- if (backend_) |
- backend_->StartSyncingWithServer(); |
-} |
- |
-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); |
-} |
- |
-void ProfileSyncService::RegisterDataTypeController( |
- std::unique_ptr<sync_driver::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( |
- syncer::ModelType type) const { |
- DataTypeController::TypeMap::const_iterator iter = |
- data_type_controllers_.find(type); |
- if (iter == data_type_controllers_.end()) { |
- return false; |
- } |
- return iter->second->state() == DataTypeController::RUNNING; |
-} |
- |
-sync_sessions::OpenTabsUIDelegate* ProfileSyncService::GetOpenTabsUIDelegate() { |
- if (!IsDataTypeControllerRunning(syncer::SESSIONS)) |
- return NULL; |
- return sessions_sync_manager_.get(); |
-} |
- |
-sync_sessions::FaviconCache* ProfileSyncService::GetFaviconCache() { |
- return sessions_sync_manager_->GetFaviconCache(); |
-} |
- |
-sync_driver::DeviceInfoTracker* ProfileSyncService::GetDeviceInfoTracker() |
- const { |
- // One of the two should always be non-null after initialization is done. |
- if (device_info_service_) { |
- return device_info_service_.get(); |
- } else { |
- return device_info_sync_service_.get(); |
- } |
-} |
- |
-sync_driver::LocalDeviceInfoProvider* |
-ProfileSyncService::GetLocalDeviceInfoProvider() const { |
- return local_device_.get(); |
-} |
- |
-void ProfileSyncService::GetDataTypeControllerStates( |
- DataTypeController::StateMap* state_map) const { |
- for (DataTypeController::TypeMap::const_iterator iter = |
- data_type_controllers_.begin(); |
- iter != data_type_controllers_.end(); ++iter) |
- (*state_map)[iter->first] = iter->second.get()->state(); |
-} |
- |
-void ProfileSyncService::OnSessionRestoreComplete() { |
- DataTypeController::TypeMap::const_iterator iter = |
- data_type_controllers_.find(syncer::SESSIONS); |
- if (iter == data_type_controllers_.end()) { |
- return; |
- } |
- DCHECK(iter->second); |
- |
- static_cast<sync_sessions::SessionDataTypeController*>(iter->second.get()) |
- ->OnSessionRestoreComplete(); |
-} |
- |
-SyncCredentials ProfileSyncService::GetCredentials() { |
- SyncCredentials 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()); |
- |
- return credentials; |
-} |
- |
-bool ProfileSyncService::ShouldDeleteSyncFolder() { |
- return !IsFirstSetupComplete(); |
-} |
- |
-void ProfileSyncService::InitializeBackend(bool delete_stale_data) { |
- if (!backend_) { |
- NOTREACHED(); |
- return; |
- } |
- |
- SyncCredentials credentials = GetCredentials(); |
- |
- if (delete_stale_data) |
- ClearStaleErrors(); |
- |
- 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, std::move(sync_thread_), db_thread_, file_thread_, |
- GetJsEventHandler(), sync_service_url_, local_device_->GetSyncUserAgent(), |
- credentials, delete_stale_data, |
- std::unique_ptr<syncer::SyncManagerFactory>( |
- new syncer::SyncManagerFactory()), |
- MakeWeakHandle(sync_enabled_weak_factory_.GetWeakPtr()), |
- base::Bind(browser_sync::ChromeReportUnrecoverableError, 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(); |
- const syncer::ModelTypeSet encrypted_types = GetEncryptedDataTypes(); |
- DCHECK(encrypted_types.Has(syncer::PASSWORDS)); |
- return !Intersection(preferred_types, encrypted_types).Empty(); |
-} |
- |
-void ProfileSyncService::OnProtocolEvent( |
- const syncer::ProtocolEvent& event) { |
- FOR_EACH_OBSERVER(browser_sync::ProtocolEventObserver, |
- protocol_event_observers_, |
- OnProtocolEvent(event)); |
-} |
- |
-void ProfileSyncService::OnDirectoryTypeCommitCounterUpdated( |
- syncer::ModelType type, |
- const syncer::CommitCounters& counters) { |
- FOR_EACH_OBSERVER(syncer::TypeDebugInfoObserver, |
- type_debug_info_observers_, |
- OnCommitCountersUpdated(type, counters)); |
-} |
- |
-void ProfileSyncService::OnDirectoryTypeUpdateCounterUpdated( |
- syncer::ModelType type, |
- const syncer::UpdateCounters& counters) { |
- FOR_EACH_OBSERVER(syncer::TypeDebugInfoObserver, |
- type_debug_info_observers_, |
- OnUpdateCountersUpdated(type, counters)); |
-} |
- |
-void ProfileSyncService::OnDirectoryTypeStatusCounterUpdated( |
- syncer::ModelType type, |
- const syncer::StatusCounters& counters) { |
- FOR_EACH_OBSERVER(syncer::TypeDebugInfoObserver, |
- type_debug_info_observers_, |
- OnStatusCountersUpdated(type, counters)); |
-} |
- |
-void ProfileSyncService::OnDataTypeRequestsSyncStartup( |
- syncer::ModelType type) { |
- DCHECK(syncer::UserTypes().Has(type)); |
- |
- if (!GetPreferredDataTypes().Has(type)) { |
- // We can get here as datatype SyncableServices are typically wired up |
- // to the native datatype even if sync isn't enabled. |
- DVLOG(1) << "Dropping sync startup request because type " |
- << syncer::ModelTypeToString(type) << "not enabled."; |
- return; |
- } |
- |
- // If this is a data type change after a major version update, reset the |
- // passphrase prompted state and notify observers. |
- if (IsPassphraseRequired() && passphrase_prompt_triggered_by_version_) { |
- // The major version has changed and a local syncable change was made. |
- // Reset the passphrase prompt state. |
- passphrase_prompt_triggered_by_version_ = false; |
- sync_prefs_.SetPassphrasePrompted(false); |
- NotifyObservers(); |
- } |
- |
- if (backend_.get()) { |
- DVLOG(1) << "A data type requested sync startup, but it looks like " |
- "something else beat it to the punch."; |
- return; |
- } |
- |
- startup_controller_->OnDataTypeRequestsSyncStartup(type); |
-} |
- |
-void ProfileSyncService::StartUpSlowBackendComponents() { |
- invalidation::InvalidationService* invalidator = |
- sync_client_->GetInvalidationService(); |
- |
- backend_.reset( |
- sync_client_->GetSyncApiComponentFactory()->CreateSyncBackendHost( |
- debug_identifier_, invalidator, sync_prefs_.AsWeakPtr(), |
- directory_path_)); |
- |
- // Initialize the backend. Every time we start up a new SyncBackendHost, |
- // we'll want to start from a fresh SyncDB, so delete any old one that might |
- // be there. |
- InitializeBackend(ShouldDeleteSyncFolder()); |
- |
- UpdateFirstSyncTimePref(); |
- |
- ReportPreviousSessionMemoryWarningCount(); |
-} |
- |
-void ProfileSyncService::OnGetTokenSuccess( |
- const OAuth2TokenService::Request* request, |
- const std::string& access_token, |
- const base::Time& expiration_time) { |
- DCHECK_EQ(access_token_request_.get(), request); |
- access_token_request_.reset(); |
- access_token_ = access_token; |
- token_receive_time_ = base::Time::Now(); |
- last_get_token_error_ = GoogleServiceAuthError::AuthErrorNone(); |
- |
- if (sync_prefs_.SyncHasAuthError()) { |
- sync_prefs_.SetSyncAuthError(false); |
- } |
- |
- if (HasSyncingBackend()) |
- backend_->UpdateCredentials(GetCredentials()); |
- else |
- startup_controller_->TryStart(); |
-} |
- |
-void ProfileSyncService::OnGetTokenFailure( |
- const OAuth2TokenService::Request* request, |
- const GoogleServiceAuthError& error) { |
- DCHECK_EQ(access_token_request_.get(), request); |
- DCHECK_NE(error.state(), GoogleServiceAuthError::NONE); |
- access_token_request_.reset(); |
- last_get_token_error_ = error; |
- switch (error.state()) { |
- case GoogleServiceAuthError::CONNECTION_FAILED: |
- case GoogleServiceAuthError::REQUEST_CANCELED: |
- case GoogleServiceAuthError::SERVICE_ERROR: |
- case GoogleServiceAuthError::SERVICE_UNAVAILABLE: { |
- // Transient error. Retry after some time. |
- request_access_token_backoff_.InformOfRequest(false); |
- next_token_request_time_ = base::Time::Now() + |
- request_access_token_backoff_.GetTimeUntilRelease(); |
- request_access_token_retry_timer_.Start( |
- FROM_HERE, request_access_token_backoff_.GetTimeUntilRelease(), |
- base::Bind(&ProfileSyncService::RequestAccessToken, |
- sync_enabled_weak_factory_.GetWeakPtr())); |
- NotifyObservers(); |
- break; |
- } |
- case GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS: { |
- if (!sync_prefs_.SyncHasAuthError()) { |
- sync_prefs_.SetSyncAuthError(true); |
- UMA_HISTOGRAM_ENUMERATION("Sync.SyncAuthError", |
- AUTH_ERROR_ENCOUNTERED, |
- AUTH_ERROR_LIMIT); |
- } |
- // Fallthrough. |
- } |
- default: { |
- if (error.state() != GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS) { |
- LOG(ERROR) << "Unexpected persistent error: " << error.ToString(); |
- } |
- // Show error to user. |
- UpdateAuthErrorState(error); |
- } |
- } |
-} |
- |
-void ProfileSyncService::OnRefreshTokenAvailable( |
- const std::string& account_id) { |
- // TODO(robliao): Remove ScopedTracker below once https://crbug.com/422460 is |
- // fixed. |
- tracked_objects::ScopedTracker tracking_profile( |
- FROM_HERE_WITH_EXPLICIT_FUNCTION( |
- "422460 ProfileSyncService::OnRefreshTokenAvailable")); |
- |
- if (account_id == signin_->GetAccountIdToUse()) |
- OnRefreshTokensLoaded(); |
-} |
- |
-void ProfileSyncService::OnRefreshTokenRevoked( |
- const std::string& account_id) { |
- if (account_id == signin_->GetAccountIdToUse()) { |
- access_token_.clear(); |
- UpdateAuthErrorState( |
- GoogleServiceAuthError(GoogleServiceAuthError::REQUEST_CANCELED)); |
- } |
-} |
- |
-void ProfileSyncService::OnRefreshTokensLoaded() { |
- // This notification gets fired when OAuth2TokenService loads the tokens |
- // from storage. |
- // Initialize the backend if sync is enabled. If the sync token was |
- // not loaded, GetCredentials() will generate invalid credentials to |
- // cause the backend to generate an auth error (crbug.com/121755). |
- if (HasSyncingBackend()) { |
- RequestAccessToken(); |
- } else { |
- startup_controller_->TryStart(); |
- } |
-} |
- |
-void ProfileSyncService::Shutdown() { |
- UnregisterAuthNotifications(); |
- |
- ShutdownImpl(syncer::BROWSER_SHUTDOWN); |
- if (sync_error_controller_) { |
- // Destroy the SyncErrorController when the service shuts down for good. |
- RemoveObserver(sync_error_controller_.get()); |
- sync_error_controller_.reset(); |
- } |
- |
- if (sync_thread_) |
- sync_thread_->Stop(); |
-} |
- |
-void ProfileSyncService::ShutdownImpl(syncer::ShutdownReason reason) { |
- if (!backend_) { |
- if (reason == syncer::ShutdownReason::DISABLE_SYNC && sync_thread_) { |
- // If the backend is already shut down when a DISABLE_SYNC happens, |
- // the data directory needs to be cleaned up here. |
- sync_thread_->task_runner()->PostTask( |
- FROM_HERE, base::Bind(&DeleteSyncDataFolder, directory_path_)); |
- } |
- return; |
- } |
- |
- if (reason == syncer::ShutdownReason::STOP_SYNC |
- || reason == syncer::ShutdownReason::DISABLE_SYNC) { |
- RemoveClientFromServer(); |
- } |
- |
- // First, we spin down the backend to stop change processing as soon as |
- // possible. |
- base::Time shutdown_start_time = base::Time::Now(); |
- backend_->StopSyncingForShutdown(); |
- |
- // Stop all data type controllers, if needed. Note that until Stop |
- // completes, it is possible in theory to have a ChangeProcessor apply a |
- // change from a native model. In that case, it will get applied to the sync |
- // database (which doesn't get destroyed until we destroy the backend below) |
- // as an unsynced change. That will be persisted, and committed on restart. |
- if (data_type_manager_) { |
- if (data_type_manager_->state() != DataTypeManager::STOPPED) { |
- // When aborting as part of shutdown, we should expect an aborted sync |
- // configure result, else we'll dcheck when we try to read the sync error. |
- expect_sync_configuration_aborted_ = true; |
- data_type_manager_->Stop(); |
- } |
- data_type_manager_.reset(); |
- } |
- |
- // Shutdown the migrator before the backend to ensure it doesn't pull a null |
- // snapshot. |
- migrator_.reset(); |
- sync_js_controller_.AttachJsBackend(WeakHandle<syncer::JsBackend>()); |
- |
- // Move aside the backend so nobody else tries to use it while we are |
- // shutting it down. |
- std::unique_ptr<SyncBackendHost> doomed_backend(backend_.release()); |
- if (doomed_backend) { |
- sync_thread_ = doomed_backend->Shutdown(reason); |
- doomed_backend.reset(); |
- } |
- base::TimeDelta shutdown_time = base::Time::Now() - shutdown_start_time; |
- UMA_HISTOGRAM_TIMES("Sync.Shutdown.BackendDestroyedTime", shutdown_time); |
- |
- sync_enabled_weak_factory_.InvalidateWeakPtrs(); |
- |
- startup_controller_->Reset(GetRegisteredDataTypes()); |
- |
- // If the sync DB is getting destroyed, the local DeviceInfo is no longer |
- // valid and should be cleared from the cache. |
- if (reason == syncer::ShutdownReason::DISABLE_SYNC) { |
- local_device_->Clear(); |
- } |
- |
- // Clear various flags. |
- expect_sync_configuration_aborted_ = false; |
- is_auth_in_progress_ = false; |
- backend_initialized_ = false; |
- cached_passphrase_.clear(); |
- encryption_pending_ = false; |
- encrypt_everything_ = false; |
- encrypted_types_ = syncer::SyncEncryptionHandler::SensitiveTypes(); |
- passphrase_required_reason_ = syncer::REASON_PASSPHRASE_NOT_REQUIRED; |
- catch_up_configure_in_progress_ = false; |
- access_token_.clear(); |
- request_access_token_retry_timer_.Stop(); |
- // Revert to "no auth error". |
- if (last_auth_error_.state() != GoogleServiceAuthError::NONE) |
- UpdateAuthErrorState(GoogleServiceAuthError::AuthErrorNone()); |
- |
- NotifyObservers(); |
- |
- // Mark this as a clean shutdown(without crash). |
- sync_prefs_.SetCleanShutdown(true); |
-} |
- |
-void ProfileSyncService::StopImpl(SyncStopDataFate data_fate) { |
- switch (data_fate) { |
- case KEEP_DATA: |
- // TODO(maxbogue): Investigate whether this logic can/should be moved |
- // into ShutdownImpl or SyncBackendHost itself. |
- if (HasSyncingBackend()) { |
- backend_->UnregisterInvalidationIds(); |
- } |
- ShutdownImpl(syncer::STOP_SYNC); |
- break; |
- case CLEAR_DATA: |
- // Clear prefs (including SyncSetupHasCompleted) before shutting down so |
- // PSS clients don't think we're set up while we're shutting down. |
- sync_prefs_.ClearPreferences(); |
- ClearUnrecoverableError(); |
- ShutdownImpl(syncer::DISABLE_SYNC); |
- break; |
- } |
-} |
- |
-bool ProfileSyncService::IsFirstSetupComplete() const { |
- return sync_prefs_.IsFirstSetupComplete(); |
-} |
- |
-void ProfileSyncService::SetFirstSetupComplete() { |
- sync_prefs_.SetFirstSetupComplete(); |
- if (IsBackendInitialized()) { |
- ReconfigureDatatypeManager(); |
- } |
-} |
- |
-void ProfileSyncService::UpdateLastSyncedTime() { |
- sync_prefs_.SetLastSyncedTime(base::Time::Now()); |
-} |
- |
-void ProfileSyncService::NotifyObservers() { |
- FOR_EACH_OBSERVER(sync_driver::SyncServiceObserver, observers_, |
- OnStateChanged()); |
-} |
- |
-void ProfileSyncService::NotifySyncCycleCompleted() { |
- FOR_EACH_OBSERVER(sync_driver::SyncServiceObserver, observers_, |
- OnSyncCycleCompleted()); |
-} |
- |
-void ProfileSyncService::NotifyForeignSessionUpdated() { |
- FOR_EACH_OBSERVER(sync_driver::SyncServiceObserver, observers_, |
- OnForeignSessionUpdated()); |
-} |
- |
-void ProfileSyncService::ClearStaleErrors() { |
- ClearUnrecoverableError(); |
- last_actionable_error_ = SyncProtocolError(); |
- // Clear the data type errors as well. |
- if (data_type_manager_.get()) |
- data_type_manager_->ResetDataTypeErrors(); |
-} |
- |
-void ProfileSyncService::ClearUnrecoverableError() { |
- unrecoverable_error_reason_ = ERROR_REASON_UNSET; |
- unrecoverable_error_message_.clear(); |
- unrecoverable_error_location_ = tracked_objects::Location(); |
-} |
- |
-// An invariant has been violated. Transition to an error state where we try |
-// to do as little work as possible, to avoid further corruption or crashes. |
-void ProfileSyncService::OnUnrecoverableError( |
- const tracked_objects::Location& from_here, |
- const std::string& message) { |
- // Unrecoverable errors that arrive via the syncer::UnrecoverableErrorHandler |
- // interface are assumed to originate within the syncer. |
- unrecoverable_error_reason_ = ERROR_REASON_SYNCER; |
- OnUnrecoverableErrorImpl(from_here, message, true); |
-} |
- |
-void ProfileSyncService::OnUnrecoverableErrorImpl( |
- const tracked_objects::Location& from_here, |
- const std::string& message, |
- bool delete_sync_database) { |
- DCHECK(HasUnrecoverableError()); |
- unrecoverable_error_message_ = message; |
- unrecoverable_error_location_ = from_here; |
- |
- UMA_HISTOGRAM_ENUMERATION(kSyncUnrecoverableErrorHistogram, |
- unrecoverable_error_reason_, |
- ERROR_REASON_LIMIT); |
- std::string location; |
- from_here.Write(true, true, &location); |
- LOG(ERROR) |
- << "Unrecoverable error detected at " << location |
- << " -- ProfileSyncService unusable: " << message; |
- |
- // Shut all data types down. |
- base::ThreadTaskRunnerHandle::Get()->PostTask( |
- FROM_HERE, base::Bind(&ProfileSyncService::ShutdownImpl, |
- sync_enabled_weak_factory_.GetWeakPtr(), |
- delete_sync_database ? syncer::DISABLE_SYNC |
- : syncer::STOP_SYNC)); |
-} |
- |
-void ProfileSyncService::ReenableDatatype(syncer::ModelType type) { |
- if (!backend_initialized_ || !data_type_manager_) |
- return; |
- data_type_manager_->ReenableType(type); |
-} |
- |
-void ProfileSyncService::UpdateBackendInitUMA(bool success) { |
- is_first_time_sync_configure_ = !IsFirstSetupComplete(); |
- |
- if (is_first_time_sync_configure_) { |
- UMA_HISTOGRAM_BOOLEAN("Sync.BackendInitializeFirstTimeSuccess", success); |
- } else { |
- UMA_HISTOGRAM_BOOLEAN("Sync.BackendInitializeRestoreSuccess", success); |
- } |
- |
- base::Time on_backend_initialized_time = base::Time::Now(); |
- base::TimeDelta delta = on_backend_initialized_time - |
- startup_controller_->start_backend_time(); |
- if (is_first_time_sync_configure_) { |
- UMA_HISTOGRAM_LONG_TIMES("Sync.BackendInitializeFirstTime", delta); |
- } else { |
- UMA_HISTOGRAM_LONG_TIMES("Sync.BackendInitializeRestoreTime", delta); |
- } |
-} |
- |
-void ProfileSyncService::PostBackendInitialization() { |
- if (protocol_event_observers_.might_have_observers()) { |
- backend_->RequestBufferedProtocolEventsAndEnableForwarding(); |
- } |
- |
- if (type_debug_info_observers_.might_have_observers()) { |
- backend_->EnableDirectoryTypeDebugInfoForwarding(); |
- } |
- |
- // If we have a cached passphrase use it to decrypt/encrypt data now that the |
- // backend is initialized. We want to call this before notifying observers in |
- // case this operation affects the "passphrase required" status. |
- ConsumeCachedPassphraseIfPossible(); |
- |
- // The very first time the backend initializes is effectively the first time |
- // we can say we successfully "synced". LastSyncedTime will only be null in |
- // this case, because the pref wasn't restored on StartUp. |
- if (sync_prefs_.GetLastSyncedTime().is_null()) { |
- UpdateLastSyncedTime(); |
- } |
- |
- // Auto-start means IsFirstSetupComplete gets set automatically. |
- if (start_behavior_ == AUTO_START && !IsFirstSetupComplete()) { |
- // This will trigger a configure if it completes setup. |
- SetFirstSetupComplete(); |
- } else if (CanConfigureDataTypes()) { |
- ConfigureDataTypeManager(); |
- } |
- |
- // Check for a cookie jar mismatch. |
- 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(); |
-} |
- |
-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); |
- |
- if (!success) { |
- // Something went unexpectedly wrong. Play it safe: stop syncing at once |
- // and surface error UI to alert the user sync has stopped. |
- // Keep the directory around for now so that on restart we will retry |
- // again and potentially succeed in presence of transient file IO failures |
- // or permissions issues, etc. |
- // |
- // TODO(rlarocque): Consider making this UnrecoverableError less special. |
- // Unlike every other UnrecoverableError, it does not delete our sync data. |
- // This exception made sense at the time it was implemented, but our new |
- // directory corruption recovery mechanism makes it obsolete. By the time |
- // we get here, we will have already tried and failed to delete the |
- // directory. It would be no big deal if we tried to delete it again. |
- 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(); |
- |
- // Initialize local device info. |
- local_device_->Initialize(cache_guid, signin_scoped_device_id, |
- blocking_pool_); |
- |
- PostBackendInitialization(); |
-} |
- |
-void ProfileSyncService::OnSyncCycleCompleted() { |
- 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())) { |
- // Trigger garbage collection of old sessions now that we've downloaded |
- // any new session data. |
- base::ThreadTaskRunnerHandle::Get()->PostTask( |
- FROM_HERE, base::Bind(&SessionsSyncManager::DoGarbageCollection, |
- base::AsWeakPtr(sessions_sync_manager_.get()))); |
- } |
- DVLOG(2) << "Notifying observers sync cycle completed"; |
- NotifySyncCycleCompleted(); |
-} |
- |
-void ProfileSyncService::OnExperimentsChanged( |
- const syncer::Experiments& experiments) { |
- if (current_experiments_.Matches(experiments)) |
- return; |
- |
- current_experiments_ = experiments; |
- |
- sync_client_->GetPrefService()->SetBoolean( |
- invalidation::prefs::kInvalidationServiceUseGCMChannel, |
- experiments.gcm_invalidations_enabled); |
-} |
- |
-void ProfileSyncService::UpdateAuthErrorState(const AuthError& error) { |
- is_auth_in_progress_ = false; |
- last_auth_error_ = error; |
- |
- NotifyObservers(); |
-} |
- |
-namespace { |
- |
-AuthError ConnectionStatusToAuthError( |
- syncer::ConnectionStatus status) { |
- switch (status) { |
- case syncer::CONNECTION_OK: |
- return AuthError::AuthErrorNone(); |
- break; |
- case syncer::CONNECTION_AUTH_ERROR: |
- return AuthError(AuthError::INVALID_GAIA_CREDENTIALS); |
- break; |
- case syncer::CONNECTION_SERVER_ERROR: |
- return AuthError(AuthError::CONNECTION_FAILED); |
- break; |
- default: |
- NOTREACHED(); |
- return AuthError(AuthError::CONNECTION_FAILED); |
- } |
-} |
- |
-} // namespace |
- |
-void ProfileSyncService::OnConnectionStatusChange( |
- syncer::ConnectionStatus status) { |
- connection_status_update_time_ = base::Time::Now(); |
- connection_status_ = status; |
- if (status == syncer::CONNECTION_AUTH_ERROR) { |
- // Sync server returned error indicating that access token is invalid. It |
- // could be either expired or access is revoked. Let's request another |
- // access token and if access is revoked then request for token will fail |
- // with corresponding error. If access token is repeatedly reported |
- // invalid, there may be some issues with server, e.g. authentication |
- // state is inconsistent on sync and token server. In that case, we |
- // backoff token requests exponentially to avoid hammering token server |
- // too much and to avoid getting same token due to token server's caching |
- // policy. |request_access_token_retry_timer_| is used to backoff request |
- // triggered by both auth error and failure talking to GAIA server. |
- // Therefore, we're likely to reach the backoff ceiling more quickly than |
- // you would expect from looking at the BackoffPolicy if both types of |
- // errors happen. We shouldn't receive two errors back-to-back without |
- // attempting a token/sync request in between, thus crank up request delay |
- // unnecessary. This is because we won't make a sync request if we hit an |
- // error until GAIA succeeds at sending a new token, and we won't request |
- // a new token unless sync reports a token failure. But to be safe, don't |
- // schedule request if this happens. |
- if (request_access_token_retry_timer_.IsRunning()) { |
- // The timer to perform a request later is already running; nothing |
- // further needs to be done at this point. |
- } else if (request_access_token_backoff_.failure_count() == 0) { |
- // First time request without delay. Currently invalid token is used |
- // to initialize sync backend and we'll always end up here. We don't |
- // want to delay initialization. |
- request_access_token_backoff_.InformOfRequest(false); |
- RequestAccessToken(); |
- } else { |
- request_access_token_backoff_.InformOfRequest(false); |
- request_access_token_retry_timer_.Start( |
- FROM_HERE, request_access_token_backoff_.GetTimeUntilRelease(), |
- base::Bind(&ProfileSyncService::RequestAccessToken, |
- sync_enabled_weak_factory_.GetWeakPtr())); |
- } |
- } else { |
- // Reset backoff time after successful connection. |
- if (status == syncer::CONNECTION_OK) { |
- // Request shouldn't be scheduled at this time. But if it is, it's |
- // possible that sync flips between OK and auth error states rapidly, |
- // thus hammers token server. To be safe, only reset backoff delay when |
- // no scheduled request. |
- if (!request_access_token_retry_timer_.IsRunning()) { |
- request_access_token_backoff_.Reset(); |
- } |
- } |
- |
- const GoogleServiceAuthError auth_error = |
- ConnectionStatusToAuthError(status); |
- DVLOG(1) << "Connection status change: " << auth_error.ToString(); |
- UpdateAuthErrorState(auth_error); |
- } |
-} |
- |
-void ProfileSyncService::OnPassphraseRequired( |
- syncer::PassphraseRequiredReason reason, |
- const sync_pb::EncryptedData& pending_keys) { |
- DCHECK(backend_.get()); |
- DCHECK(backend_->IsNigoriEnabled()); |
- |
- // TODO(lipalani) : add this check to other locations as well. |
- if (HasUnrecoverableError()) { |
- // When unrecoverable error is detected we post a task to shutdown the |
- // backend. The task might not have executed yet. |
- return; |
- } |
- |
- DVLOG(1) << "Passphrase required with reason: " |
- << syncer::PassphraseRequiredReasonToString(reason); |
- passphrase_required_reason_ = reason; |
- |
- // TODO(stanisc): http://crbug.com/351005: Does this support USS types? |
- const syncer::ModelTypeSet types = GetPreferredDataTypes(); |
- if (data_type_manager_) { |
- // Reconfigure without the encrypted types (excluded implicitly via the |
- // failed datatypes handler). |
- data_type_manager_->Configure(types, syncer::CONFIGURE_REASON_CRYPTO); |
- } |
- |
- // Notify observers that the passphrase status may have changed. |
- NotifyObservers(); |
-} |
- |
-void ProfileSyncService::OnPassphraseAccepted() { |
- DVLOG(1) << "Received OnPassphraseAccepted."; |
- |
- // If the pending keys were resolved via keystore, it's possible we never |
- // consumed our cached passphrase. Clear it now. |
- if (!cached_passphrase_.empty()) |
- cached_passphrase_.clear(); |
- |
- // Reset passphrase_required_reason_ since we know we no longer require the |
- // passphrase. We do this here rather than down in ResolvePassphraseRequired() |
- // because that can be called by OnPassphraseRequired() if no encrypted data |
- // types are enabled, and we don't want to clobber the true passphrase error. |
- passphrase_required_reason_ = syncer::REASON_PASSPHRASE_NOT_REQUIRED; |
- |
- // Make sure the data types that depend on the passphrase are started at |
- // this time. |
- // TODO(stanisc): http://crbug.com/351005: Does this support USS types? |
- const syncer::ModelTypeSet types = GetPreferredDataTypes(); |
- if (data_type_manager_) { |
- // Re-enable any encrypted types if necessary. |
- data_type_manager_->Configure(types, syncer::CONFIGURE_REASON_CRYPTO); |
- } |
- |
- NotifyObservers(); |
-} |
- |
-void ProfileSyncService::OnEncryptedTypesChanged( |
- syncer::ModelTypeSet encrypted_types, |
- bool encrypt_everything) { |
- encrypted_types_ = encrypted_types; |
- encrypt_everything_ = encrypt_everything; |
- DCHECK(encrypt_everything_allowed_ || !encrypt_everything_); |
- DVLOG(1) << "Encrypted types changed to " |
- << syncer::ModelTypeSetToString(encrypted_types_) |
- << " (encrypt everything is set to " |
- << (encrypt_everything_ ? "true" : "false") << ")"; |
- DCHECK(encrypted_types_.Has(syncer::PASSWORDS)); |
- |
- NotifyObservers(); |
-} |
- |
-void ProfileSyncService::OnEncryptionComplete() { |
- DVLOG(1) << "Encryption complete"; |
- if (encryption_pending_ && encrypt_everything_) { |
- encryption_pending_ = false; |
- // This is to nudge the integration tests when encryption is |
- // finished. |
- NotifyObservers(); |
- } |
-} |
- |
-void ProfileSyncService::OnMigrationNeededForTypes( |
- syncer::ModelTypeSet types) { |
- DCHECK(backend_initialized_); |
- DCHECK(data_type_manager_.get()); |
- |
- // Migrator must be valid, because we don't sync until it is created and this |
- // callback originates from a sync cycle. |
- migrator_->MigrateTypes(types); |
-} |
- |
-void ProfileSyncService::OnActionableError(const SyncProtocolError& error) { |
- last_actionable_error_ = error; |
- DCHECK_NE(last_actionable_error_.action, |
- syncer::UNKNOWN_ACTION); |
- switch (error.action) { |
- case syncer::UPGRADE_CLIENT: |
- case syncer::CLEAR_USER_DATA_AND_RESYNC: |
- case syncer::ENABLE_SYNC_ON_ACCOUNT: |
- case syncer::STOP_AND_RESTART_SYNC: |
- // TODO(lipalani) : if setup in progress we want to display these |
- // actions in the popup. The current experience might not be optimal for |
- // the user. We just dismiss the dialog. |
- if (startup_controller_->IsSetupInProgress()) { |
- RequestStop(CLEAR_DATA); |
- expect_sync_configuration_aborted_ = true; |
- } |
- // Trigger an unrecoverable error to stop syncing. |
- OnInternalUnrecoverableError(FROM_HERE, |
- last_actionable_error_.error_description, |
- true, |
- ERROR_REASON_ACTIONABLE_ERROR); |
- break; |
- case syncer::DISABLE_SYNC_ON_CLIENT: |
- if (error.error_type == syncer::NOT_MY_BIRTHDAY) { |
- UMA_HISTOGRAM_ENUMERATION("Sync.StopSource", syncer::BIRTHDAY_ERROR, |
- syncer::STOP_SOURCE_LIMIT); |
- } |
- RequestStop(CLEAR_DATA); |
-#if !defined(OS_CHROMEOS) |
- // On every platform except ChromeOS, sign out the user after a dashboard |
- // clear. |
- static_cast<SigninManager*>(signin_->GetOriginal()) |
- ->SignOut(signin_metrics::SERVER_FORCED_DISABLE, |
- signin_metrics::SignoutDelete::IGNORE_METRIC); |
-#endif |
- break; |
- case syncer::STOP_SYNC_FOR_DISABLED_ACCOUNT: |
- // Sync disabled by domain admin. we should stop syncing until next |
- // restart. |
- sync_disabled_by_admin_ = true; |
- ShutdownImpl(syncer::DISABLE_SYNC); |
- break; |
- case syncer::RESET_LOCAL_SYNC_DATA: |
- ShutdownImpl(syncer::DISABLE_SYNC); |
- startup_controller_->TryStart(); |
- break; |
- default: |
- NOTREACHED(); |
- } |
- NotifyObservers(); |
-} |
- |
-void ProfileSyncService::OnLocalSetPassphraseEncryption( |
- const syncer::SyncEncryptionHandler::NigoriState& nigori_state) { |
- DCHECK(thread_checker_.CalledOnValidThread()); |
- if (!base::FeatureList::IsEnabled( |
- switches::kSyncClearDataOnPassphraseEncryption)) |
- return; |
- |
- // At this point the user has set a custom passphrase and we have received the |
- // updated nigori state. Time to cache the nigori state, and catch up the |
- // active data types. |
- sync_prefs_.SetSavedNigoriStateForPassphraseEncryptionTransition( |
- nigori_state); |
- sync_prefs_.SetPassphraseEncryptionTransitionInProgress(true); |
- BeginConfigureCatchUpBeforeClear(); |
-} |
- |
-void ProfileSyncService::BeginConfigureCatchUpBeforeClear() { |
- DCHECK(data_type_manager_); |
- DCHECK(!saved_nigori_state_); |
- saved_nigori_state_ = |
- sync_prefs_.GetSavedNigoriStateForPassphraseEncryptionTransition(); |
- const syncer::ModelTypeSet types = GetActiveDataTypes(); |
- catch_up_configure_in_progress_ = true; |
- data_type_manager_->Configure(types, syncer::CONFIGURE_REASON_CATCH_UP); |
-} |
- |
-void ProfileSyncService::ClearAndRestartSyncForPassphraseEncryption() { |
- DCHECK(thread_checker_.CalledOnValidThread()); |
- backend_->ClearServerData( |
- base::Bind(&ProfileSyncService::OnClearServerDataDone, |
- sync_enabled_weak_factory_.GetWeakPtr())); |
-} |
- |
-void ProfileSyncService::OnClearServerDataDone() { |
- DCHECK(sync_prefs_.GetPassphraseEncryptionTransitionInProgress()); |
- sync_prefs_.SetPassphraseEncryptionTransitionInProgress(false); |
- |
- // Call to ClearServerData generates new keystore key on the server. This |
- // makes keystore bootstrap token invalid. Let's clear it from preferences. |
- sync_prefs_.SetKeystoreEncryptionBootstrapToken(std::string()); |
- |
- // Shutdown sync, delete the Directory, then restart, restoring the cached |
- // nigori state. |
- ShutdownImpl(syncer::DISABLE_SYNC); |
- startup_controller_->TryStart(); |
-} |
- |
-void ProfileSyncService::OnConfigureDone( |
- const DataTypeManager::ConfigureResult& result) { |
- configure_status_ = result.status; |
- data_type_status_table_ = result.data_type_status_table; |
- |
- // We should have cleared our cached passphrase before we get here (in |
- // OnBackendInitialized()). |
- DCHECK(cached_passphrase_.empty()); |
- |
- if (!sync_configure_start_time_.is_null()) { |
- if (result.status == DataTypeManager::OK) { |
- base::Time sync_configure_stop_time = base::Time::Now(); |
- base::TimeDelta delta = sync_configure_stop_time - |
- sync_configure_start_time_; |
- if (is_first_time_sync_configure_) { |
- UMA_HISTOGRAM_LONG_TIMES("Sync.ServiceInitialConfigureTime", delta); |
- } else { |
- UMA_HISTOGRAM_LONG_TIMES("Sync.ServiceSubsequentConfigureTime", |
- delta); |
- } |
- } |
- sync_configure_start_time_ = base::Time(); |
- } |
- |
- // Notify listeners that configuration is done. |
- FOR_EACH_OBSERVER(sync_driver::SyncServiceObserver, observers_, |
- OnSyncConfigurationCompleted()); |
- |
- DVLOG(1) << "PSS OnConfigureDone called with status: " << configure_status_; |
- // The possible status values: |
- // ABORT - Configuration was aborted. This is not an error, if |
- // initiated by user. |
- // OK - Some or all types succeeded. |
- // Everything else is an UnrecoverableError. So treat it as such. |
- |
- // First handle the abort case. |
- if (configure_status_ == DataTypeManager::ABORTED && |
- expect_sync_configuration_aborted_) { |
- DVLOG(0) << "ProfileSyncService::Observe Sync Configure aborted"; |
- expect_sync_configuration_aborted_ = false; |
- return; |
- } |
- |
- // Handle unrecoverable error. |
- if (configure_status_ != DataTypeManager::OK) { |
- // Something catastrophic had happened. We should only have one |
- // error representing it. |
- syncer::SyncError error = |
- data_type_status_table_.GetUnrecoverableError(); |
- DCHECK(error.IsSet()); |
- std::string message = |
- "Sync configuration failed with status " + |
- DataTypeManager::ConfigureStatusToString(configure_status_) + |
- " caused by " + |
- syncer::ModelTypeSetToString( |
- data_type_status_table_.GetUnrecoverableErrorTypes()) + |
- ": " + error.message(); |
- LOG(ERROR) << "ProfileSyncService error: " << message; |
- OnInternalUnrecoverableError(error.location(), |
- message, |
- true, |
- ERROR_REASON_CONFIGURATION_FAILURE); |
- return; |
- } |
- |
- DCHECK_EQ(DataTypeManager::OK, configure_status_); |
- |
- // We should never get in a state where we have no encrypted datatypes |
- // enabled, and yet we still think we require a passphrase for decryption. |
- DCHECK(!(IsPassphraseRequiredForDecryption() && |
- !IsEncryptedDatatypeEnabled())); |
- |
- // This must be done before we start syncing with the server to avoid |
- // sending unencrypted data up on a first time sync. |
- if (encryption_pending_) |
- backend_->EnableEncryptEverything(); |
- NotifyObservers(); |
- |
- if (migrator_.get() && |
- migrator_->state() != browser_sync::BackendMigrator::IDLE) { |
- // Migration in progress. Let the migrator know we just finished |
- // configuring something. It will be up to the migrator to call |
- // StartSyncingWithServer() if migration is now finished. |
- migrator_->OnConfigureDone(result); |
- return; |
- } |
- |
- if (catch_up_configure_in_progress_) { |
- catch_up_configure_in_progress_ = false; |
- ClearAndRestartSyncForPassphraseEncryption(); |
- return; |
- } |
- |
- StartSyncingWithServer(); |
-} |
- |
-void ProfileSyncService::OnConfigureStart() { |
- sync_configure_start_time_ = base::Time::Now(); |
- NotifyObservers(); |
-} |
- |
-ProfileSyncService::SyncStatusSummary |
- ProfileSyncService::QuerySyncStatusSummary() { |
- if (HasUnrecoverableError()) { |
- return UNRECOVERABLE_ERROR; |
- } else if (!backend_) { |
- return NOT_ENABLED; |
- } else if (backend_.get() && !IsFirstSetupComplete()) { |
- return SETUP_INCOMPLETE; |
- } else if (backend_ && IsFirstSetupComplete() && data_type_manager_ && |
- data_type_manager_->state() == DataTypeManager::STOPPED) { |
- return DATATYPES_NOT_INITIALIZED; |
- } else if (IsSyncActive()) { |
- return INITIALIZED; |
- } |
- return UNKNOWN_ERROR; |
-} |
- |
-std::string ProfileSyncService::QuerySyncStatusSummaryString() { |
- SyncStatusSummary status = QuerySyncStatusSummary(); |
- |
- std::string config_status_str = |
- configure_status_ != DataTypeManager::UNKNOWN ? |
- DataTypeManager::ConfigureStatusToString(configure_status_) : ""; |
- |
- switch (status) { |
- case UNRECOVERABLE_ERROR: |
- return "Unrecoverable error detected"; |
- case NOT_ENABLED: |
- return "Syncing not enabled"; |
- case SETUP_INCOMPLETE: |
- return "First time sync setup incomplete"; |
- case DATATYPES_NOT_INITIALIZED: |
- return "Datatypes not fully initialized"; |
- case INITIALIZED: |
- return "Sync service initialized"; |
- default: |
- return "Status unknown: Internal error?"; |
- } |
-} |
- |
-std::string ProfileSyncService::GetBackendInitializationStateString() const { |
- return startup_controller_->GetBackendInitializationStateString(); |
-} |
- |
-bool ProfileSyncService::IsSetupInProgress() const { |
- return startup_controller_->IsSetupInProgress(); |
-} |
- |
-bool ProfileSyncService::QueryDetailedSyncStatus( |
- SyncBackendHost::Status* result) { |
- if (backend_.get() && backend_initialized_) { |
- *result = backend_->GetDetailedStatus(); |
- return true; |
- } else { |
- SyncBackendHost::Status status; |
- status.sync_protocol_error = last_actionable_error_; |
- *result = status; |
- return false; |
- } |
-} |
- |
-const AuthError& ProfileSyncService::GetAuthError() const { |
- return last_auth_error_; |
-} |
- |
-bool ProfileSyncService::CanConfigureDataTypes() const { |
- return IsFirstSetupComplete() && !IsSetupInProgress(); |
-} |
- |
-bool ProfileSyncService::IsFirstSetupInProgress() const { |
- return !IsFirstSetupComplete() && startup_controller_->IsSetupInProgress(); |
-} |
- |
-std::unique_ptr<sync_driver::SyncSetupInProgressHandle> |
-ProfileSyncService::GetSetupInProgressHandle() { |
- if (++outstanding_setup_in_progress_handles_ == 1) { |
- DCHECK(!startup_controller_->IsSetupInProgress()); |
- startup_controller_->SetSetupInProgress(true); |
- |
- NotifyObservers(); |
- } |
- |
- return std::unique_ptr<sync_driver::SyncSetupInProgressHandle>( |
- new sync_driver::SyncSetupInProgressHandle( |
- base::Bind(&ProfileSyncService::OnSetupInProgressHandleDestroyed, |
- weak_factory_.GetWeakPtr()))); |
-} |
- |
-bool ProfileSyncService::IsSyncAllowed() const { |
- return IsSyncAllowedByFlag() && !IsManaged() && IsSyncAllowedByPlatform(); |
-} |
- |
-bool ProfileSyncService::IsSyncActive() const { |
- return backend_initialized_ && data_type_manager_ && |
- data_type_manager_->state() != DataTypeManager::STOPPED; |
-} |
- |
-void ProfileSyncService::TriggerRefresh(const syncer::ModelTypeSet& types) { |
- 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 { |
- return CanSyncStart() && oauth2_token_service_ && |
- oauth2_token_service_->RefreshTokenIsAvailable( |
- signin_->GetAccountIdToUse()); |
-} |
- |
-bool ProfileSyncService::IsBackendInitialized() const { |
- return backend_initialized_; |
-} |
- |
-bool ProfileSyncService::ConfigurationDone() const { |
- return data_type_manager_ && |
- data_type_manager_->state() == DataTypeManager::CONFIGURED; |
-} |
- |
-bool ProfileSyncService::waiting_for_auth() const { |
- return is_auth_in_progress_; |
-} |
- |
-const syncer::Experiments& ProfileSyncService::current_experiments() const { |
- return current_experiments_; |
-} |
- |
-bool ProfileSyncService::HasUnrecoverableError() const { |
- return unrecoverable_error_reason_ != ERROR_REASON_UNSET; |
-} |
- |
-bool ProfileSyncService::IsPassphraseRequired() const { |
- return passphrase_required_reason_ != |
- syncer::REASON_PASSPHRASE_NOT_REQUIRED; |
-} |
- |
-bool ProfileSyncService::IsPassphraseRequiredForDecryption() const { |
- // If there is an encrypted datatype enabled and we don't have the proper |
- // passphrase, we must prompt the user for a passphrase. The only way for the |
- // user to avoid entering their passphrase is to disable the encrypted types. |
- return IsEncryptedDatatypeEnabled() && IsPassphraseRequired(); |
-} |
- |
-base::string16 ProfileSyncService::GetLastSyncedTimeString() const { |
- const base::Time last_synced_time = sync_prefs_.GetLastSyncedTime(); |
- if (last_synced_time.is_null()) |
- return l10n_util::GetStringUTF16(IDS_SYNC_TIME_NEVER); |
- |
- base::TimeDelta time_since_last_sync = base::Time::Now() - last_synced_time; |
- |
- if (time_since_last_sync < base::TimeDelta::FromMinutes(1)) |
- return l10n_util::GetStringUTF16(IDS_SYNC_TIME_JUST_NOW); |
- |
- return ui::TimeFormat::Simple(ui::TimeFormat::FORMAT_ELAPSED, |
- ui::TimeFormat::LENGTH_SHORT, |
- time_since_last_sync); |
-} |
- |
-void ProfileSyncService::UpdateSelectedTypesHistogram( |
- bool sync_everything, const syncer::ModelTypeSet chosen_types) const { |
- if (!IsFirstSetupComplete() || |
- sync_everything != sync_prefs_.HasKeepEverythingSynced()) { |
- UMA_HISTOGRAM_BOOLEAN("Sync.SyncEverything", sync_everything); |
- } |
- |
- // Only log the data types that are shown in the sync settings ui. |
- // Note: the order of these types must match the ordering of |
- // the respective types in ModelType |
- const sync_driver::user_selectable_type::UserSelectableSyncType |
- user_selectable_types[] = { |
- sync_driver::user_selectable_type::BOOKMARKS, |
- sync_driver::user_selectable_type::PREFERENCES, |
- sync_driver::user_selectable_type::PASSWORDS, |
- sync_driver::user_selectable_type::AUTOFILL, |
- sync_driver::user_selectable_type::THEMES, |
- sync_driver::user_selectable_type::TYPED_URLS, |
- sync_driver::user_selectable_type::EXTENSIONS, |
- sync_driver::user_selectable_type::APPS, |
- sync_driver::user_selectable_type::PROXY_TABS, |
- }; |
- |
- static_assert(38 == syncer::MODEL_TYPE_COUNT, |
- "custom config histogram must be updated"); |
- |
- if (!sync_everything) { |
- const syncer::ModelTypeSet current_types = GetPreferredDataTypes(); |
- |
- syncer::ModelTypeSet type_set = syncer::UserSelectableTypes(); |
- syncer::ModelTypeSet::Iterator it = type_set.First(); |
- |
- DCHECK_EQ(arraysize(user_selectable_types), type_set.Size()); |
- |
- for (size_t i = 0; i < arraysize(user_selectable_types) && it.Good(); |
- ++i, it.Inc()) { |
- const syncer::ModelType type = it.Get(); |
- if (chosen_types.Has(type) && |
- (!IsFirstSetupComplete() || !current_types.Has(type))) { |
- // Selected type has changed - log it. |
- UMA_HISTOGRAM_ENUMERATION( |
- "Sync.CustomSync", |
- user_selectable_types[i], |
- sync_driver::user_selectable_type::SELECTABLE_DATATYPE_COUNT + 1); |
- } |
- } |
- } |
-} |
- |
-#if defined(OS_CHROMEOS) |
-void ProfileSyncService::RefreshSpareBootstrapToken( |
- const std::string& passphrase) { |
- sync_driver::SystemEncryptor encryptor; |
- syncer::Cryptographer temp_cryptographer(&encryptor); |
- // The first 2 params (hostname and username) doesn't have any effect here. |
- syncer::KeyParams key_params = {"localhost", "dummy", passphrase}; |
- |
- std::string bootstrap_token; |
- if (!temp_cryptographer.AddKey(key_params)) { |
- NOTREACHED() << "Failed to add key to cryptographer."; |
- } |
- temp_cryptographer.GetBootstrapToken(&bootstrap_token); |
- sync_prefs_.SetSpareBootstrapToken(bootstrap_token); |
-} |
-#endif |
- |
-void ProfileSyncService::OnUserChoseDatatypes( |
- bool sync_everything, |
- syncer::ModelTypeSet chosen_types) { |
- DCHECK(syncer::UserSelectableTypes().HasAll(chosen_types)); |
- |
- if (!backend_.get() && !HasUnrecoverableError()) { |
- NOTREACHED(); |
- return; |
- } |
- |
- UpdateSelectedTypesHistogram(sync_everything, chosen_types); |
- sync_prefs_.SetKeepEverythingSynced(sync_everything); |
- |
- if (data_type_manager_) |
- data_type_manager_->ResetDataTypeErrors(); |
- ChangePreferredDataTypes(chosen_types); |
-} |
- |
-void ProfileSyncService::ChangePreferredDataTypes( |
- syncer::ModelTypeSet preferred_types) { |
- |
- DVLOG(1) << "ChangePreferredDataTypes invoked"; |
- const syncer::ModelTypeSet registered_types = GetRegisteredDataTypes(); |
- // Will only enable those types that are registered and preferred. |
- sync_prefs_.SetPreferredDataTypes(registered_types, preferred_types); |
- |
- // Now reconfigure the DTM. |
- ReconfigureDatatypeManager(); |
-} |
- |
-syncer::ModelTypeSet ProfileSyncService::GetActiveDataTypes() const { |
- if (!IsSyncActive() || !ConfigurationDone()) |
- return syncer::ModelTypeSet(); |
- const syncer::ModelTypeSet preferred_types = GetPreferredDataTypes(); |
- const syncer::ModelTypeSet failed_types = |
- data_type_status_table_.GetFailedTypes(); |
- return Difference(preferred_types, failed_types); |
-} |
- |
-sync_driver::SyncClient* ProfileSyncService::GetSyncClient() const { |
- return sync_client_.get(); |
-} |
- |
-syncer::ModelTypeSet ProfileSyncService::GetPreferredDataTypes() const { |
- const syncer::ModelTypeSet registered_types = GetRegisteredDataTypes(); |
- const syncer::ModelTypeSet preferred_types = |
- Union(sync_prefs_.GetPreferredDataTypes(registered_types), |
- syncer::ControlTypes()); |
- const syncer::ModelTypeSet enforced_types = |
- Intersection(GetDataTypesFromPreferenceProviders(), registered_types); |
- return Union(preferred_types, enforced_types); |
-} |
- |
-syncer::ModelTypeSet ProfileSyncService::GetForcedDataTypes() const { |
- // TODO(treib,zea): When SyncPrefs also implements SyncTypePreferenceProvider, |
- // we'll need another way to distinguish user-choosable types from |
- // programmatically-enabled types. |
- return GetDataTypesFromPreferenceProviders(); |
-} |
- |
-syncer::ModelTypeSet ProfileSyncService::GetRegisteredDataTypes() const { |
- syncer::ModelTypeSet registered_types; |
- // The data_type_controllers_ are determined by command-line flags; |
- // that's effectively what controls the values returned here. |
- for (DataTypeController::TypeMap::const_iterator it = |
- data_type_controllers_.begin(); |
- it != data_type_controllers_.end(); ++it) { |
- registered_types.Put(it->first); |
- } |
- return registered_types; |
-} |
- |
-bool ProfileSyncService::IsUsingSecondaryPassphrase() const { |
- syncer::PassphraseType passphrase_type = GetPassphraseType(); |
- return passphrase_type == |
- syncer::PassphraseType::FROZEN_IMPLICIT_PASSPHRASE || |
- passphrase_type == syncer::PassphraseType::CUSTOM_PASSPHRASE; |
-} |
- |
-std::string ProfileSyncService::GetCustomPassphraseKey() const { |
- sync_driver::SystemEncryptor encryptor; |
- syncer::Cryptographer cryptographer(&encryptor); |
- cryptographer.Bootstrap(sync_prefs_.GetEncryptionBootstrapToken()); |
- return cryptographer.GetDefaultNigoriKeyData(); |
-} |
- |
-syncer::PassphraseType ProfileSyncService::GetPassphraseType() const { |
- return backend_->GetPassphraseType(); |
-} |
- |
-base::Time ProfileSyncService::GetExplicitPassphraseTime() const { |
- return backend_->GetExplicitPassphraseTime(); |
-} |
- |
-bool ProfileSyncService::IsCryptographerReady( |
- const syncer::BaseTransaction* trans) const { |
- return backend_.get() && backend_->IsCryptographerReady(trans); |
-} |
- |
-void ProfileSyncService::SetPlatformSyncAllowedProvider( |
- const PlatformSyncAllowedProvider& platform_sync_allowed_provider) { |
- platform_sync_allowed_provider_ = platform_sync_allowed_provider; |
-} |
- |
-void ProfileSyncService::ConfigureDataTypeManager() { |
- // Don't configure datatypes if the setup UI is still on the screen - this |
- // is to help multi-screen setting UIs (like iOS) where they don't want to |
- // start syncing data until the user is done configuring encryption options, |
- // etc. ReconfigureDatatypeManager() will get called again once the UI calls |
- // SetSetupInProgress(false). |
- if (!CanConfigureDataTypes()) { |
- // If we can't configure the data type manager yet, we should still notify |
- // observers. This is to support multiple setup UIs being open at once. |
- NotifyObservers(); |
- return; |
- } |
- |
- bool restart = false; |
- if (!data_type_manager_) { |
- restart = true; |
- data_type_manager_.reset( |
- sync_client_->GetSyncApiComponentFactory()->CreateDataTypeManager( |
- debug_info_listener_, &data_type_controllers_, this, backend_.get(), |
- this)); |
- |
- // We create the migrator at the same time. |
- migrator_.reset(new browser_sync::BackendMigrator( |
- debug_identifier_, GetUserShare(), this, data_type_manager_.get(), |
- base::Bind(&ProfileSyncService::StartSyncingWithServer, |
- base::Unretained(this)))); |
- } |
- |
- syncer::ModelTypeSet types; |
- syncer::ConfigureReason reason = syncer::CONFIGURE_REASON_UNKNOWN; |
- types = GetPreferredDataTypes(); |
- if (restart) { |
- // Datatype downloads on restart are generally due to newly supported |
- // datatypes (although it's also possible we're picking up where a failed |
- // previous configuration left off). |
- // TODO(sync): consider detecting configuration recovery and setting |
- // the reason here appropriately. |
- reason = syncer::CONFIGURE_REASON_NEWLY_ENABLED_DATA_TYPE; |
- } else { |
- // The user initiated a reconfiguration (either to add or remove types). |
- reason = syncer::CONFIGURE_REASON_RECONFIGURATION; |
- } |
- |
- data_type_manager_->Configure(types, reason); |
-} |
- |
-syncer::UserShare* ProfileSyncService::GetUserShare() const { |
- if (backend_.get() && backend_initialized_) { |
- return backend_->GetUserShare(); |
- } |
- NOTREACHED(); |
- return NULL; |
-} |
- |
-syncer::SyncCycleSnapshot ProfileSyncService::GetLastCycleSnapshot() const { |
- if (backend_) |
- return backend_->GetLastCycleSnapshot(); |
- return syncer::SyncCycleSnapshot(); |
-} |
- |
-bool ProfileSyncService::HasUnsyncedItems() const { |
- if (HasSyncingBackend() && backend_initialized_) { |
- return backend_->HasUnsyncedItems(); |
- } |
- NOTREACHED(); |
- return false; |
-} |
- |
-browser_sync::BackendMigrator* |
-ProfileSyncService::GetBackendMigratorForTest() { |
- return migrator_.get(); |
-} |
- |
-void ProfileSyncService::GetModelSafeRoutingInfo( |
- syncer::ModelSafeRoutingInfo* out) const { |
- if (backend_.get() && backend_initialized_) { |
- backend_->GetModelSafeRoutingInfo(out); |
- } else { |
- NOTREACHED(); |
- } |
-} |
- |
-base::Value* ProfileSyncService::GetTypeStatusMap() const { |
- std::unique_ptr<base::ListValue> result(new base::ListValue()); |
- |
- if (!backend_.get() || !backend_initialized_) { |
- return result.release(); |
- } |
- |
- DataTypeStatusTable::TypeErrorMap error_map = |
- data_type_status_table_.GetAllErrors(); |
- ModelTypeSet active_types; |
- ModelTypeSet passive_types; |
- ModelSafeRoutingInfo routing_info; |
- backend_->GetModelSafeRoutingInfo(&routing_info); |
- for (ModelSafeRoutingInfo::const_iterator it = routing_info.begin(); |
- it != routing_info.end(); ++it) { |
- if (it->second == syncer::GROUP_PASSIVE) { |
- passive_types.Put(it->first); |
- } else { |
- active_types.Put(it->first); |
- } |
- } |
- |
- SyncBackendHost::Status detailed_status = backend_->GetDetailedStatus(); |
- ModelTypeSet& throttled_types(detailed_status.throttled_types); |
- ModelTypeSet registered = GetRegisteredDataTypes(); |
- std::unique_ptr<base::DictionaryValue> type_status_header( |
- new base::DictionaryValue()); |
- |
- type_status_header->SetString("name", "Model Type"); |
- type_status_header->SetString("status", "header"); |
- type_status_header->SetString("value", "Group Type"); |
- type_status_header->SetString("num_entries", "Total Entries"); |
- type_status_header->SetString("num_live", "Live Entries"); |
- result->Append(std::move(type_status_header)); |
- |
- std::unique_ptr<base::DictionaryValue> type_status; |
- for (ModelTypeSet::Iterator it = registered.First(); it.Good(); it.Inc()) { |
- ModelType type = it.Get(); |
- |
- type_status.reset(new base::DictionaryValue()); |
- type_status->SetString("name", ModelTypeToString(type)); |
- |
- if (error_map.find(type) != error_map.end()) { |
- const syncer::SyncError &error = error_map.find(type)->second; |
- DCHECK(error.IsSet()); |
- switch (error.GetSeverity()) { |
- case syncer::SyncError::SYNC_ERROR_SEVERITY_ERROR: { |
- std::string error_text = "Error: " + error.location().ToString() + |
- ", " + error.GetMessagePrefix() + error.message(); |
- type_status->SetString("status", "error"); |
- type_status->SetString("value", error_text); |
- } |
- break; |
- case syncer::SyncError::SYNC_ERROR_SEVERITY_INFO: |
- type_status->SetString("status", "disabled"); |
- type_status->SetString("value", error.message()); |
- break; |
- default: |
- NOTREACHED() << "Unexpected error severity."; |
- break; |
- } |
- } else if (syncer::IsProxyType(type) && passive_types.Has(type)) { |
- // Show a proxy type in "ok" state unless it is disabled by user. |
- DCHECK(!throttled_types.Has(type)); |
- type_status->SetString("status", "ok"); |
- type_status->SetString("value", "Passive"); |
- } else if (throttled_types.Has(type) && passive_types.Has(type)) { |
- type_status->SetString("status", "warning"); |
- type_status->SetString("value", "Passive, Throttled"); |
- } else if (passive_types.Has(type)) { |
- type_status->SetString("status", "warning"); |
- type_status->SetString("value", "Passive"); |
- } else if (throttled_types.Has(type)) { |
- type_status->SetString("status", "warning"); |
- type_status->SetString("value", "Throttled"); |
- } else if (active_types.Has(type)) { |
- type_status->SetString("status", "ok"); |
- type_status->SetString("value", "Active: " + |
- ModelSafeGroupToString(routing_info[type])); |
- } else { |
- type_status->SetString("status", "warning"); |
- type_status->SetString("value", "Disabled by User"); |
- } |
- |
- int live_count = detailed_status.num_entries_by_type[type] - |
- detailed_status.num_to_delete_entries_by_type[type]; |
- type_status->SetInteger("num_entries", |
- detailed_status.num_entries_by_type[type]); |
- type_status->SetInteger("num_live", live_count); |
- |
- result->Append(std::move(type_status)); |
- } |
- return result.release(); |
-} |
- |
-void ProfileSyncService::ConsumeCachedPassphraseIfPossible() { |
- // If no cached passphrase, or sync backend hasn't started up yet, just exit. |
- // If the backend isn't running yet, OnBackendInitialized() will call this |
- // method again after the backend starts up. |
- if (cached_passphrase_.empty() || !IsBackendInitialized()) |
- return; |
- |
- // Backend is up and running, so we can consume the cached passphrase. |
- std::string passphrase = cached_passphrase_; |
- cached_passphrase_.clear(); |
- |
- // If we need a passphrase to decrypt data, try the cached passphrase. |
- if (passphrase_required_reason() == syncer::REASON_DECRYPTION) { |
- if (SetDecryptionPassphrase(passphrase)) { |
- DVLOG(1) << "Cached passphrase successfully decrypted pending keys"; |
- return; |
- } |
- } |
- |
- // If we get here, we don't have pending keys (or at least, the passphrase |
- // doesn't decrypt them) - just try to re-encrypt using the encryption |
- // passphrase. |
- if (!IsUsingSecondaryPassphrase()) |
- SetEncryptionPassphrase(passphrase, IMPLICIT); |
-} |
- |
-void ProfileSyncService::RequestAccessToken() { |
- // Only one active request at a time. |
- if (access_token_request_ != NULL) |
- return; |
- request_access_token_retry_timer_.Stop(); |
- OAuth2TokenService::ScopeSet oauth2_scopes; |
- oauth2_scopes.insert(signin_->GetSyncScopeToUse()); |
- |
- // Invalidate previous token, otherwise token service will return the same |
- // token again. |
- const std::string& account_id = signin_->GetAccountIdToUse(); |
- if (!access_token_.empty()) { |
- oauth2_token_service_->InvalidateAccessToken(account_id, oauth2_scopes, |
- access_token_); |
- } |
- |
- access_token_.clear(); |
- |
- token_request_time_ = base::Time::Now(); |
- token_receive_time_ = base::Time(); |
- next_token_request_time_ = base::Time(); |
- access_token_request_ = |
- oauth2_token_service_->StartRequest(account_id, oauth2_scopes, this); |
-} |
- |
-void ProfileSyncService::SetEncryptionPassphrase(const std::string& passphrase, |
- PassphraseType type) { |
- // This should only be called when the backend has been initialized. |
- DCHECK(IsBackendInitialized()); |
- DCHECK(!(type == IMPLICIT && IsUsingSecondaryPassphrase())) << |
- "Data is already encrypted using an explicit passphrase"; |
- DCHECK(!(type == EXPLICIT && |
- passphrase_required_reason_ == syncer::REASON_DECRYPTION)) << |
- "Can not set explicit passphrase when decryption is needed."; |
- |
- DVLOG(1) << "Setting " << (type == EXPLICIT ? "explicit" : "implicit") |
- << " passphrase for encryption."; |
- if (passphrase_required_reason_ == syncer::REASON_ENCRYPTION) { |
- // REASON_ENCRYPTION implies that the cryptographer does not have pending |
- // keys. Hence, as long as we're not trying to do an invalid passphrase |
- // change (e.g. explicit -> explicit or explicit -> implicit), we know this |
- // will succeed. If for some reason a new encryption key arrives via |
- // sync later, the SBH will trigger another OnPassphraseRequired(). |
- passphrase_required_reason_ = syncer::REASON_PASSPHRASE_NOT_REQUIRED; |
- NotifyObservers(); |
- } |
- backend_->SetEncryptionPassphrase(passphrase, type == EXPLICIT); |
-} |
- |
-bool ProfileSyncService::SetDecryptionPassphrase( |
- const std::string& passphrase) { |
- if (IsPassphraseRequired()) { |
- DVLOG(1) << "Setting passphrase for decryption."; |
- bool result = backend_->SetDecryptionPassphrase(passphrase); |
- UMA_HISTOGRAM_BOOLEAN("Sync.PassphraseDecryptionSucceeded", result); |
- return result; |
- } else { |
- NOTREACHED() << "SetDecryptionPassphrase must not be called when " |
- "IsPassphraseRequired() is false."; |
- return false; |
- } |
-} |
- |
-bool ProfileSyncService::IsEncryptEverythingAllowed() const { |
- return encrypt_everything_allowed_; |
-} |
- |
-void ProfileSyncService::SetEncryptEverythingAllowed(bool allowed) { |
- DCHECK(allowed || !IsBackendInitialized() || !IsEncryptEverythingEnabled()); |
- encrypt_everything_allowed_ = allowed; |
-} |
- |
-void ProfileSyncService::EnableEncryptEverything() { |
- DCHECK(IsEncryptEverythingAllowed()); |
- |
- // Tests override IsBackendInitialized() to always return true, so we |
- // must check that instead of |backend_initialized_|. |
- // TODO(akalin): Fix the above. :/ |
- DCHECK(IsBackendInitialized()); |
- // TODO(atwilson): Persist the encryption_pending_ flag to address the various |
- // problems around cancelling encryption in the background (crbug.com/119649). |
- if (!encrypt_everything_) |
- encryption_pending_ = true; |
-} |
- |
-bool ProfileSyncService::encryption_pending() const { |
- // We may be called during the setup process before we're |
- // initialized (via IsEncryptedDatatypeEnabled and |
- // IsPassphraseRequiredForDecryption). |
- return encryption_pending_; |
-} |
- |
-bool ProfileSyncService::IsEncryptEverythingEnabled() const { |
- DCHECK(backend_initialized_); |
- return encrypt_everything_ || encryption_pending_; |
-} |
- |
-syncer::ModelTypeSet ProfileSyncService::GetEncryptedDataTypes() const { |
- DCHECK(encrypted_types_.Has(syncer::PASSWORDS)); |
- // We may be called during the setup process before we're |
- // initialized. In this case, we default to the sensitive types. |
- return encrypted_types_; |
-} |
- |
-void ProfileSyncService::OnSyncManagedPrefChange(bool is_sync_managed) { |
- if (is_sync_managed) { |
- StopImpl(CLEAR_DATA); |
- } else { |
- // Sync is no longer disabled by policy. Try starting it up if appropriate. |
- startup_controller_->TryStart(); |
- } |
-} |
- |
-void ProfileSyncService::GoogleSigninSucceeded(const std::string& account_id, |
- const std::string& username, |
- const std::string& password) { |
- if (IsSyncRequested() && !password.empty()) { |
- cached_passphrase_ = password; |
- // Try to consume the passphrase we just cached. If the sync backend |
- // is not running yet, the passphrase will remain cached until the |
- // backend starts up. |
- ConsumeCachedPassphraseIfPossible(); |
- } |
-#if defined(OS_CHROMEOS) |
- RefreshSpareBootstrapToken(password); |
-#endif |
- if (!IsBackendInitialized() || GetAuthError().state() != AuthError::NONE) { |
- // Track the fact that we're still waiting for auth to complete. |
- is_auth_in_progress_ = true; |
- } |
-} |
- |
-void ProfileSyncService::GoogleSignedOut(const std::string& account_id, |
- const std::string& username) { |
- sync_disabled_by_admin_ = false; |
- UMA_HISTOGRAM_ENUMERATION("Sync.StopSource", syncer::SIGN_OUT, |
- syncer::STOP_SOURCE_LIMIT); |
- RequestStop(CLEAR_DATA); |
-} |
- |
-void ProfileSyncService::OnGaiaAccountsInCookieUpdated( |
- const std::vector<gaia::ListedAccount>& accounts, |
- const std::vector<gaia::ListedAccount>& signed_out_accounts, |
- const GoogleServiceAuthError& error) { |
- if (!IsBackendInitialized()) |
- return; |
- |
- bool cookie_jar_mismatch = true; |
- bool cookie_jar_empty = accounts.size() == 0; |
- std::string account_id = signin_->GetAccountIdToUse(); |
- |
- // Iterate through list of accounts, looking for current sync account. |
- for (const auto& account : accounts) { |
- if (account.id == account_id) { |
- cookie_jar_mismatch = false; |
- break; |
- } |
- } |
- |
- DVLOG(1) << "Cookie jar mismatch: " << cookie_jar_mismatch; |
- DVLOG(1) << "Cookie jar empty: " << cookie_jar_empty; |
- backend_->OnCookieJarChanged(cookie_jar_mismatch, cookie_jar_empty); |
-} |
- |
-void ProfileSyncService::AddObserver( |
- sync_driver::SyncServiceObserver* observer) { |
- observers_.AddObserver(observer); |
-} |
- |
-void ProfileSyncService::RemoveObserver( |
- sync_driver::SyncServiceObserver* observer) { |
- observers_.RemoveObserver(observer); |
-} |
- |
-void ProfileSyncService::AddProtocolEventObserver( |
- browser_sync::ProtocolEventObserver* observer) { |
- protocol_event_observers_.AddObserver(observer); |
- if (HasSyncingBackend()) { |
- backend_->RequestBufferedProtocolEventsAndEnableForwarding(); |
- } |
-} |
- |
-void ProfileSyncService::RemoveProtocolEventObserver( |
- browser_sync::ProtocolEventObserver* observer) { |
- protocol_event_observers_.RemoveObserver(observer); |
- if (HasSyncingBackend() && |
- !protocol_event_observers_.might_have_observers()) { |
- backend_->DisableProtocolEventForwarding(); |
- } |
-} |
- |
-void ProfileSyncService::AddTypeDebugInfoObserver( |
- syncer::TypeDebugInfoObserver* type_debug_info_observer) { |
- type_debug_info_observers_.AddObserver(type_debug_info_observer); |
- if (type_debug_info_observers_.might_have_observers() && |
- backend_initialized_) { |
- backend_->EnableDirectoryTypeDebugInfoForwarding(); |
- } |
-} |
- |
-void ProfileSyncService::RemoveTypeDebugInfoObserver( |
- syncer::TypeDebugInfoObserver* type_debug_info_observer) { |
- type_debug_info_observers_.RemoveObserver(type_debug_info_observer); |
- if (!type_debug_info_observers_.might_have_observers() && |
- backend_initialized_) { |
- backend_->DisableDirectoryTypeDebugInfoForwarding(); |
- } |
-} |
- |
-void ProfileSyncService::AddPreferenceProvider( |
- SyncTypePreferenceProvider* provider) { |
- DCHECK(!HasPreferenceProvider(provider)) |
- << "Providers may only be added once!"; |
- preference_providers_.insert(provider); |
-} |
- |
-void ProfileSyncService::RemovePreferenceProvider( |
- SyncTypePreferenceProvider* provider) { |
- DCHECK(HasPreferenceProvider(provider)) |
- << "Only providers that have been added before can be removed!"; |
- preference_providers_.erase(provider); |
-} |
- |
-bool ProfileSyncService::HasPreferenceProvider( |
- SyncTypePreferenceProvider* provider) const { |
- return preference_providers_.count(provider) > 0; |
-} |
- |
-namespace { |
- |
-class GetAllNodesRequestHelper |
- : public base::RefCountedThreadSafe<GetAllNodesRequestHelper> { |
- public: |
- GetAllNodesRequestHelper( |
- syncer::ModelTypeSet requested_types, |
- const base::Callback<void(std::unique_ptr<base::ListValue>)>& callback); |
- |
- void OnReceivedNodesForType(const syncer::ModelType type, |
- std::unique_ptr<base::ListValue> node_list); |
- |
- private: |
- friend class base::RefCountedThreadSafe<GetAllNodesRequestHelper>; |
- virtual ~GetAllNodesRequestHelper(); |
- |
- std::unique_ptr<base::ListValue> result_accumulator_; |
- |
- syncer::ModelTypeSet awaiting_types_; |
- base::Callback<void(std::unique_ptr<base::ListValue>)> callback_; |
-}; |
- |
-GetAllNodesRequestHelper::GetAllNodesRequestHelper( |
- syncer::ModelTypeSet requested_types, |
- const base::Callback<void(std::unique_ptr<base::ListValue>)>& callback) |
- : result_accumulator_(new base::ListValue()), |
- awaiting_types_(requested_types), |
- callback_(callback) {} |
- |
-GetAllNodesRequestHelper::~GetAllNodesRequestHelper() { |
- if (!awaiting_types_.Empty()) { |
- DLOG(WARNING) |
- << "GetAllNodesRequest deleted before request was fulfilled. " |
- << "Missing types are: " << ModelTypeSetToString(awaiting_types_); |
- } |
-} |
- |
-// Called when the set of nodes for a type has been returned. |
-// Only return one type of nodes each time. |
-void GetAllNodesRequestHelper::OnReceivedNodesForType( |
- const syncer::ModelType type, |
- std::unique_ptr<base::ListValue> node_list) { |
- // Add these results to our list. |
- std::unique_ptr<base::DictionaryValue> type_dict(new base::DictionaryValue()); |
- type_dict->SetString("type", ModelTypeToString(type)); |
- type_dict->Set("nodes", std::move(node_list)); |
- result_accumulator_->Append(std::move(type_dict)); |
- |
- // Remember that this part of the request is satisfied. |
- awaiting_types_.Remove(type); |
- |
- if (awaiting_types_.Empty()) { |
- callback_.Run(std::move(result_accumulator_)); |
- callback_.Reset(); |
- } |
-} |
- |
-} // namespace |
- |
-void ProfileSyncService::GetAllNodes( |
- const base::Callback<void(std::unique_ptr<base::ListValue>)>& callback) { |
- // TODO(stanisc): crbug.com/328606: Make this work for USS datatypes. |
- ModelTypeSet all_types = GetActiveDataTypes(); |
- all_types.PutAll(syncer::ControlTypes()); |
- scoped_refptr<GetAllNodesRequestHelper> helper = |
- new GetAllNodesRequestHelper(all_types, callback); |
- |
- if (!backend_initialized_) { |
- // If there's no backend available to fulfill the request, handle it here. |
- for (ModelTypeSet::Iterator it = all_types.First(); it.Good(); it.Inc()) { |
- helper->OnReceivedNodesForType(it.Get(), |
- base::MakeUnique<base::ListValue>()); |
- } |
- return; |
- } |
- |
- for (ModelTypeSet::Iterator it = all_types.First(); it.Good(); it.Inc()) { |
- const auto& dtc_iter = data_type_controllers_.find(it.Get()); |
- if (dtc_iter != data_type_controllers_.end()) { |
- dtc_iter->second->GetAllNodes(base::Bind( |
- &GetAllNodesRequestHelper::OnReceivedNodesForType, helper)); |
- } else { |
- // Control Types |
- helper->OnReceivedNodesForType( |
- it.Get(), sync_driver::DirectoryDataTypeController:: |
- GetAllNodesForTypeFromDirectory( |
- it.Get(), GetUserShare()->directory.get())); |
- } |
- } |
-} |
- |
-bool ProfileSyncService::HasObserver( |
- const sync_driver::SyncServiceObserver* observer) const { |
- return observers_.HasObserver(observer); |
-} |
- |
-base::WeakPtr<syncer::JsController> ProfileSyncService::GetJsController() { |
- return sync_js_controller_.AsWeakPtr(); |
-} |
- |
-void ProfileSyncService::SyncEvent(SyncEventCodes code) { |
- UMA_HISTOGRAM_ENUMERATION("Sync.EventCodes", code, MAX_SYNC_EVENT_CODE); |
-} |
- |
-// static |
-bool ProfileSyncService::IsSyncAllowedByFlag() { |
- return !base::CommandLine::ForCurrentProcess()->HasSwitch( |
- switches::kDisableSync); |
-} |
- |
-bool ProfileSyncService::IsSyncAllowedByPlatform() const { |
- return platform_sync_allowed_provider_.is_null() || |
- platform_sync_allowed_provider_.Run(); |
-} |
- |
-bool ProfileSyncService::IsManaged() const { |
- return sync_prefs_.IsManaged() || sync_disabled_by_admin_; |
-} |
- |
-void ProfileSyncService::RequestStop(SyncStopDataFate data_fate) { |
- sync_prefs_.SetSyncRequested(false); |
- StopImpl(data_fate); |
-} |
- |
-bool ProfileSyncService::IsSyncRequested() const { |
- return sync_prefs_.IsSyncRequested(); |
-} |
- |
-SigninManagerBase* ProfileSyncService::signin() const { |
- if (!signin_) |
- return NULL; |
- return signin_->GetOriginal(); |
-} |
- |
-void ProfileSyncService::RequestStart() { |
- if (!IsSyncAllowed()) { |
- // Sync cannot be requested if it's not allowed. |
- return; |
- } |
- DCHECK(sync_client_); |
- if (!IsSyncRequested()) { |
- sync_prefs_.SetSyncRequested(true); |
- NotifyObservers(); |
- } |
- startup_controller_->TryStartImmediately(); |
-} |
- |
-void ProfileSyncService::ReconfigureDatatypeManager() { |
- // If we haven't initialized yet, don't configure the DTM as it could cause |
- // association to start before a Directory has even been created. |
- if (backend_initialized_) { |
- DCHECK(backend_.get()); |
- ConfigureDataTypeManager(); |
- } else if (HasUnrecoverableError()) { |
- // There is nothing more to configure. So inform the listeners, |
- NotifyObservers(); |
- |
- DVLOG(1) << "ConfigureDataTypeManager not invoked because of an " |
- << "Unrecoverable error."; |
- } else { |
- DVLOG(0) << "ConfigureDataTypeManager not invoked because backend is not " |
- << "initialized"; |
- } |
-} |
- |
-syncer::ModelTypeSet ProfileSyncService::GetDataTypesFromPreferenceProviders() |
- const { |
- syncer::ModelTypeSet types; |
- for (std::set<SyncTypePreferenceProvider*>::const_iterator it = |
- preference_providers_.begin(); |
- it != preference_providers_.end(); |
- ++it) { |
- types.PutAll((*it)->GetPreferredDataTypes()); |
- } |
- return types; |
-} |
- |
-const DataTypeStatusTable& ProfileSyncService::data_type_status_table() |
- const { |
- return data_type_status_table_; |
-} |
- |
-void ProfileSyncService::OnInternalUnrecoverableError( |
- const tracked_objects::Location& from_here, |
- const std::string& message, |
- bool delete_sync_database, |
- UnrecoverableErrorReason reason) { |
- DCHECK(!HasUnrecoverableError()); |
- unrecoverable_error_reason_ = reason; |
- OnUnrecoverableErrorImpl(from_here, message, delete_sync_database); |
-} |
- |
-bool ProfileSyncService::IsRetryingAccessTokenFetchForTest() const { |
- return request_access_token_retry_timer_.IsRunning(); |
-} |
- |
-std::string ProfileSyncService::GetAccessTokenForTest() const { |
- return access_token_; |
-} |
- |
-WeakHandle<syncer::JsEventHandler> ProfileSyncService::GetJsEventHandler() { |
- return MakeWeakHandle(sync_js_controller_.AsWeakPtr()); |
-} |
- |
-syncer::SyncableService* ProfileSyncService::GetSessionsSyncableService() { |
- return sessions_sync_manager_.get(); |
-} |
- |
-syncer::SyncableService* ProfileSyncService::GetDeviceInfoSyncableService() { |
- return device_info_sync_service_.get(); |
-} |
- |
-syncer_v2::ModelTypeService* ProfileSyncService::GetDeviceInfoService() { |
- return device_info_service_.get(); |
-} |
- |
-sync_driver::SyncService::SyncTokenStatus |
-ProfileSyncService::GetSyncTokenStatus() const { |
- SyncTokenStatus status; |
- status.connection_status_update_time = connection_status_update_time_; |
- status.connection_status = connection_status_; |
- status.token_request_time = token_request_time_; |
- status.token_receive_time = token_receive_time_; |
- status.last_get_token_error = last_get_token_error_; |
- if (request_access_token_retry_timer_.IsRunning()) |
- status.next_token_request_time = next_token_request_time_; |
- return status; |
-} |
- |
-void ProfileSyncService::OverrideNetworkResourcesForTest( |
- std::unique_ptr<syncer::NetworkResources> network_resources) { |
- network_resources_ = std::move(network_resources); |
-} |
- |
-bool ProfileSyncService::HasSyncingBackend() const { |
- return backend_ != NULL; |
-} |
- |
-void ProfileSyncService::UpdateFirstSyncTimePref() { |
- if (!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. |
- if (backend_initialized_) |
- backend_->FlushDirectory(); |
-} |
- |
-base::FilePath ProfileSyncService::GetDirectoryPathForTest() const { |
- return directory_path_; |
-} |
- |
-base::MessageLoop* ProfileSyncService::GetSyncLoopForTest() const { |
- if (sync_thread_) { |
- return sync_thread_->message_loop(); |
- } else if (backend_) { |
- return backend_->GetSyncLoopForTesting(); |
- } else { |
- return NULL; |
- } |
-} |
- |
-void ProfileSyncService::RefreshTypesForTest(syncer::ModelTypeSet types) { |
- if (backend_initialized_) |
- backend_->RefreshTypesForTest(types); |
-} |
- |
-void ProfileSyncService::RemoveClientFromServer() const { |
- if (!backend_initialized_) return; |
- const std::string cache_guid = local_device_->GetLocalSyncCacheGUID(); |
- std::string birthday; |
- syncer::UserShare* user_share = GetUserShare(); |
- if (user_share && user_share->directory.get()) { |
- birthday = user_share->directory->store_birthday(); |
- } |
- if (!access_token_.empty() && !cache_guid.empty() && !birthday.empty()) { |
- sync_stopped_reporter_->ReportSyncStopped( |
- access_token_, cache_guid, birthday); |
- } |
-} |
- |
-void ProfileSyncService::OnMemoryPressure( |
- base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) { |
- if (memory_pressure_level == |
- base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) { |
- sync_prefs_.SetMemoryPressureWarningCount( |
- sync_prefs_.GetMemoryPressureWarningCount() + 1); |
- } |
-} |
- |
-void ProfileSyncService::ReportPreviousSessionMemoryWarningCount() { |
- int warning_received = sync_prefs_.GetMemoryPressureWarningCount(); |
- |
- if (-1 != warning_received) { |
- // -1 means it is new client. |
- if (!sync_prefs_.DidSyncShutdownCleanly()) { |
- UMA_HISTOGRAM_COUNTS("Sync.MemoryPressureWarningBeforeUncleanShutdown", |
- warning_received); |
- } else { |
- UMA_HISTOGRAM_COUNTS("Sync.MemoryPressureWarningBeforeCleanShutdown", |
- warning_received); |
- } |
- } |
- sync_prefs_.SetMemoryPressureWarningCount(0); |
- // Will set to true during a clean shutdown, so crash or something else will |
- // remain this as false. |
- sync_prefs_.SetCleanShutdown(false); |
-} |
- |
-const GURL& ProfileSyncService::sync_service_url() const { |
- return sync_service_url_; |
-} |
- |
-std::string ProfileSyncService::unrecoverable_error_message() const { |
- return unrecoverable_error_message_; |
-} |
- |
-tracked_objects::Location ProfileSyncService::unrecoverable_error_location() |
- const { |
- return unrecoverable_error_location_; |
-} |
- |
-void ProfileSyncService::OnSetupInProgressHandleDestroyed() { |
- DCHECK_GT(outstanding_setup_in_progress_handles_, 0); |
- |
- // Don't re-start Sync until all outstanding handles are destroyed. |
- if (--outstanding_setup_in_progress_handles_ != 0) |
- return; |
- |
- DCHECK(startup_controller_->IsSetupInProgress()); |
- startup_controller_->SetSetupInProgress(false); |
- |
- if (IsBackendInitialized()) |
- ReconfigureDatatypeManager(); |
- NotifyObservers(); |
-} |