#include "base/callback.h"
#include "base/command_line.h"
#include "base/compiler_specific.h"
-#include "base/file_util.h"
+#include "base/files/file_util.h"
#include "base/logging.h"
#include "base/memory/ref_counted.h"
#include "base/message_loop/message_loop.h"
#include "chrome/browser/bookmarks/enhanced_bookmarks_features.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/browsing_data/browsing_data_helper.h"
-#include "chrome/browser/browsing_data/browsing_data_remover.h"
#include "chrome/browser/chrome_notification_types.h"
#include "chrome/browser/defaults.h"
#include "chrome/browser/invalidation/profile_invalidation_provider_factory.h"
#include "chrome/browser/signin/signin_manager_factory.h"
#include "chrome/browser/sync/backend_migrator.h"
#include "chrome/browser/sync/glue/chrome_report_unrecoverable_error.h"
-#include "chrome/browser/sync/glue/device_info.h"
#include "chrome/browser/sync/glue/favicon_cache.h"
#include "chrome/browser/sync/glue/sync_backend_host.h"
#include "chrome/browser/sync/glue/sync_backend_host_impl.h"
#include "chrome/browser/sync/glue/sync_start_util.h"
-#include "chrome/browser/sync/glue/synced_device_tracker.h"
#include "chrome/browser/sync/glue/typed_url_data_type_controller.h"
#include "chrome/browser/sync/profile_sync_components_factory_impl.h"
#include "chrome/browser/sync/sessions/notification_service_sessions_router.h"
-#include "chrome/browser/sync/sessions/sessions_sync_manager.h"
#include "chrome/browser/sync/supervised_user_signin_manager_wrapper.h"
#include "chrome/browser/sync/sync_error_controller.h"
#include "chrome/browser/sync/sync_type_preference_provider.h"
#include "chrome/common/chrome_version_info.h"
#include "chrome/common/pref_names.h"
#include "chrome/common/url_constants.h"
+#include "chrome/grit/generated_resources.h"
#include "components/gcm_driver/gcm_driver.h"
#include "components/invalidation/invalidation_service.h"
#include "components/invalidation/profile_invalidation_provider.h"
#include "components/signin/core/browser/signin_metrics.h"
#include "components/sync_driver/change_processor.h"
#include "components/sync_driver/data_type_controller.h"
+#include "components/sync_driver/device_info.h"
#include "components/sync_driver/pref_names.h"
#include "components/sync_driver/system_encryptor.h"
#include "components/sync_driver/user_selectable_sync_type.h"
#include "content/public/browser/notification_details.h"
#include "content/public/browser/notification_service.h"
#include "content/public/browser/notification_source.h"
-#include "grit/generated_resources.h"
#include "net/cookies/cookie_monster.h"
#include "net/url_request/url_request_context_getter.h"
#include "sync/api/sync_error.h"
using browser_sync::NotificationServiceSessionsRouter;
using browser_sync::ProfileSyncServiceStartBehavior;
+using browser_sync::SessionsSyncManager;
using browser_sync::SyncBackendHost;
using sync_driver::ChangeProcessor;
using sync_driver::DataTypeController;
using sync_driver::DataTypeManager;
-using sync_driver::FailedDataTypesHandler;
+using sync_driver::DataTypeStatusTable;
+using sync_driver::DeviceInfoSyncService;
using syncer::ModelType;
using syncer::ModelTypeSet;
using syncer::JsBackend;
namespace {
-void ClearBrowsingData(Profile* profile, base::Time start, base::Time end) {
+void ClearBrowsingData(BrowsingDataRemover::Observer* observer,
+ Profile* profile,
+ base::Time start,
+ base::Time end) {
// BrowsingDataRemover deletes itself when it's done.
BrowsingDataRemover* remover = BrowsingDataRemover::CreateForRange(
profile, start, end);
+ if (observer)
+ remover->AddObserver(observer);
remover->Remove(BrowsingDataRemover::REMOVE_ALL,
BrowsingDataHelper::ALL);
- password_manager::PasswordStore* password =
+ scoped_refptr<password_manager::PasswordStore> password =
PasswordStoreFactory::GetForProfile(profile, Profile::EXPLICIT_ACCESS);
password->RemoveLoginsSyncedBetween(start, end);
}
backend_mode_(IDLE),
need_backup_(false),
backup_finished_(false),
- clear_browsing_data_(base::Bind(&ClearBrowsingData)) {
+ clear_browsing_data_(base::Bind(&ClearBrowsingData)),
+ browsing_data_remover_observer_(NULL) {
DCHECK(profile);
syncer::SyncableService::StartSyncFlare flare(
sync_start_util::GetFlareForSyncableService(profile->GetPath()));
local_device_ = factory_->CreateLocalDeviceInfoProvider();
sessions_sync_manager_.reset(
new SessionsSyncManager(profile, local_device_.get(), router.Pass()));
+ device_info_sync_service_.reset(
+ new DeviceInfoSyncService(local_device_.get()));
}
ProfileSyncService::~ProfileSyncService() {
UMA_HISTOGRAM_COUNTS("Sync.DatatypePrefRecovery", 1);
sync_prefs_.SetKeepEverythingSynced(true);
syncer::ModelTypeSet registered_types = GetRegisteredDataTypes();
- sync_prefs_.SetPreferredDataTypes(registered_types,
- registered_types);
}
void ProfileSyncService::StartSyncingWithServer() {
type, task_runner, type_sync_proxy);
}
-bool ProfileSyncService::IsSessionsDataTypeControllerRunning() const {
- return directory_data_type_controllers_.find(syncer::SESSIONS) !=
- directory_data_type_controllers_.end() &&
- (directory_data_type_controllers_.find(syncer::SESSIONS)->
- second->state() == DataTypeController::RUNNING);
+bool ProfileSyncService::IsDataTypeControllerRunning(
+ syncer::ModelType type) const {
+ DataTypeController::TypeMap::const_iterator iter =
+ directory_data_type_controllers_.find(type);
+ if (iter == directory_data_type_controllers_.end()) {
+ return false;
+ }
+ return iter->second->state() == DataTypeController::RUNNING;
}
browser_sync::OpenTabsUIDelegate* ProfileSyncService::GetOpenTabsUIDelegate() {
- if (!IsSessionsDataTypeControllerRunning())
+ if (!IsDataTypeControllerRunning(syncer::SESSIONS))
return NULL;
return sessions_sync_manager_.get();
}
return sessions_sync_manager_->GetSyncedWindowDelegatesGetter();
}
-browser_sync::LocalDeviceInfoProvider*
-ProfileSyncService::GetLocalDeviceInfoProvider() {
- return local_device_.get();
-}
-
-scoped_ptr<browser_sync::DeviceInfo>
-ProfileSyncService::GetDeviceInfo(const std::string& client_id) const {
- if (HasSyncingBackend()) {
- browser_sync::SyncedDeviceTracker* device_tracker =
- backend_->GetSyncedDeviceTracker();
- if (device_tracker)
- return device_tracker->ReadDeviceInfo(client_id);
- }
- return scoped_ptr<browser_sync::DeviceInfo>();
-}
-
-ScopedVector<browser_sync::DeviceInfo>
- ProfileSyncService::GetAllSignedInDevices() const {
- ScopedVector<browser_sync::DeviceInfo> devices;
- if (HasSyncingBackend()) {
- browser_sync::SyncedDeviceTracker* device_tracker =
- backend_->GetSyncedDeviceTracker();
- if (device_tracker) {
- // TODO(lipalani) - Make device tracker return a scoped vector.
- device_tracker->GetAllSyncedDeviceInfo(&devices);
- }
- }
- return devices.Pass();
-}
+sync_driver::DeviceInfoTracker* ProfileSyncService::GetDeviceInfoTracker()
+ const {
+ if (!IsDataTypeControllerRunning(syncer::DEVICE_INFO))
+ return NULL;
-// Notifies the observer of any device info changes.
-void ProfileSyncService::AddObserverForDeviceInfoChange(
- browser_sync::SyncedDeviceTracker::Observer* observer) {
- if (HasSyncingBackend()) {
- browser_sync::SyncedDeviceTracker* device_tracker =
- backend_->GetSyncedDeviceTracker();
- if (device_tracker) {
- device_tracker->AddObserver(observer);
- }
- }
+ return device_info_sync_service_.get();
}
-// Removes the observer from device info change notification.
-void ProfileSyncService::RemoveObserverForDeviceInfoChange(
- browser_sync::SyncedDeviceTracker::Observer* observer) {
- if (HasSyncingBackend()) {
- browser_sync::SyncedDeviceTracker* device_tracker =
- backend_->GetSyncedDeviceTracker();
- if (device_tracker) {
- device_tracker->RemoveObserver(observer);
- }
- }
+sync_driver::LocalDeviceInfoProvider*
+ProfileSyncService::GetLocalDeviceInfoProvider() {
+ return local_device_.get();
}
void ProfileSyncService::GetDataTypeControllerStates(
backup_start_time_ = base::Time::Now();
if (backend_mode_ == SYNC && !backup_start_time_.is_null()) {
- UMA_HISTOGRAM_TIMES("first-sync-delay-by-backup",
- base::Time::Now() - backup_start_time_);
+ UMA_HISTOGRAM_MEDIUM_TIMES("Sync.FirstSyncDelayByBackup",
+ base::Time::Now() - backup_start_time_);
backup_start_time_ = base::Time();
}
InitializeBackend(ShouldDeleteSyncFolder());
UpdateFirstSyncTimePref();
+
+ NotifyObservers();
}
void ProfileSyncService::OnGetTokenSuccess(
ClearUnrecoverableError();
last_actionable_error_ = SyncProtocolError();
// Clear the data type errors as well.
- failed_data_types_handler_.Reset();
+ if (directory_data_type_manager_.get())
+ directory_data_type_manager_->ResetDataTypeErrors();
+
}
void ProfileSyncService::ClearUnrecoverableError() {
}
void ProfileSyncService::ReenableDatatype(syncer::ModelType type) {
- // Only reconfigure if the type actually had a data type or unready error.
- if (!failed_data_types_handler_.ResetDataTypeErrorFor(type) &&
- !failed_data_types_handler_.ResetUnreadyErrorFor(type)) {
- return;
- }
-
- // If the type is no longer enabled, don't bother reconfiguring.
- // TODO(zea): something else should encapsulate the notion of "whether a type
- // should be enabled".
- if (!syncer::CoreTypes().Has(type) && !GetPreferredDataTypes().Has(type))
- return;
-
- base::MessageLoop::current()->PostTask(FROM_HERE,
- base::Bind(&ProfileSyncService::ReconfigureDatatypeManager,
- weak_factory_.GetWeakPtr()));
+ DCHECK(backend_initialized_);
+ directory_data_type_manager_->ReenableType(type);
}
void ProfileSyncService::UpdateBackendInitUMA(bool success) {
DCHECK_EQ(backend_mode_, SYNC);
if (last_backup_time_) {
- browser_sync::SyncedDeviceTracker* device_tracker =
- backend_->GetSyncedDeviceTracker();
- if (device_tracker)
- device_tracker->UpdateLocalDeviceBackupTime(*last_backup_time_);
+ DCHECK(device_info_sync_service_);
+ device_info_sync_service_->UpdateLocalDeviceBackupTime(*last_backup_time_);
}
if (protocol_event_observers_.might_have_observers()) {
// Initialize local device info.
local_device_->Initialize(cache_guid, signin_scoped_device_id);
+ DVLOG(1) << "Setting preferred types for non-blocking DTM";
+ non_blocking_data_type_manager_.SetPreferredTypes(GetPreferredDataTypes());
+
// Give the DataTypeControllers a handle to the now initialized backend
// as a UserShare.
for (DataTypeController::TypeMap::iterator it =
void ProfileSyncService::OnSyncCycleCompleted() {
UpdateLastSyncedTime();
- if (IsSessionsDataTypeControllerRunning()) {
+ if (IsDataTypeControllerRunning(syncer::SESSIONS)) {
// Trigger garbage collection of old sessions now that we've downloaded
// any new session data.
base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
- &browser_sync::SessionsSyncManager::DoGarbageCollection,
+ &SessionsSyncManager::DoGarbageCollection,
base::AsWeakPtr(sessions_sync_manager_.get())));
}
DVLOG(2) << "Notifying observers sync cycle completed";
<< (encrypt_everything_ ? "true" : "false") << ")";
DCHECK(encrypted_types_.Has(syncer::PASSWORDS));
- // If sessions are encrypted, full history sync is not possible, and
- // delete directives are unnecessary.
- if (GetActiveDataTypes().Has(syncer::HISTORY_DELETE_DIRECTIVES) &&
- encrypted_types_.Has(syncer::SESSIONS)) {
- syncer::SyncError error(
- FROM_HERE,
- syncer::SyncError::DATATYPE_POLICY_ERROR,
- "Delete directives not supported with encryption.",
- syncer::HISTORY_DELETE_DIRECTIVES);
- FailedDataTypesHandler::TypeErrorMap error_map;
- error_map[error.model_type()] = error;
- failed_data_types_handler_.UpdateFailedDataTypes(error_map);
- ReconfigureDatatypeManager();
- }
+ NotifyObservers();
}
void ProfileSyncService::OnEncryptionComplete() {
void ProfileSyncService::OnConfigureDone(
const DataTypeManager::ConfigureResult& result) {
configure_status_ = result.status;
+ data_type_status_table_ = result.data_type_status_table;
if (backend_mode_ != SYNC) {
if (configure_status_ == DataTypeManager::OK) {
// Something catastrophic had happened. We should only have one
// error representing it.
syncer::SyncError error =
- failed_data_types_handler_.GetUnrecoverableError();
+ data_type_status_table_.GetUnrecoverableError();
DCHECK(error.IsSet());
std::string message =
"Sync configuration failed with status " +
DataTypeManager::ConfigureStatusToString(configure_status_) +
" caused by " +
syncer::ModelTypeSetToString(
- failed_data_types_handler_.GetUnrecoverableErrorTypes()) +
+ data_type_status_table_.GetUnrecoverableErrorTypes()) +
": " + error.message();
LOG(ERROR) << "ProfileSyncService error: " << message;
OnInternalUnrecoverableError(error.location(),
// 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
+ const sync_driver::user_selectable_type::UserSelectableSyncType
user_selectable_types[] = {
sync_driver::user_selectable_type::BOOKMARKS,
sync_driver::user_selectable_type::PREFERENCES,
UpdateSelectedTypesHistogram(sync_everything, chosen_types);
sync_prefs_.SetKeepEverythingSynced(sync_everything);
- failed_data_types_handler_.Reset();
- if (GetActiveDataTypes().Has(syncer::HISTORY_DELETE_DIRECTIVES) &&
- encrypted_types_.Has(syncer::SESSIONS)) {
- syncer::SyncError error(
- FROM_HERE,
- syncer::SyncError::DATATYPE_POLICY_ERROR,
- "Delete directives not supported with encryption.",
- syncer::HISTORY_DELETE_DIRECTIVES);
- FailedDataTypesHandler::TypeErrorMap error_map;
- error_map[error.model_type()] = error;
- failed_data_types_handler_.UpdateFailedDataTypes(error_map);
- }
+ if (directory_data_type_manager_.get())
+ directory_data_type_manager_->ResetDataTypeErrors();
ChangePreferredDataTypes(chosen_types);
AcknowledgeSyncedTypes();
NotifyObservers();
syncer::ModelTypeSet ProfileSyncService::GetActiveDataTypes() const {
const syncer::ModelTypeSet preferred_types = GetPreferredDataTypes();
const syncer::ModelTypeSet failed_types =
- failed_data_types_handler_.GetFailedTypes();
+ data_type_status_table_.GetFailedTypes();
return Difference(preferred_types, failed_types);
}
const syncer::ModelTypeSet registered_types = GetRegisteredDataTypes();
const syncer::ModelTypeSet preferred_types =
sync_prefs_.GetPreferredDataTypes(registered_types);
- return preferred_types;
+ const syncer::ModelTypeSet enforced_types =
+ Intersection(GetDataTypesFromPreferenceProviders(), registered_types);
+ return Union(preferred_types, enforced_types);
}
syncer::ModelTypeSet
GetRegisteredDirectoryDataTypes();
const syncer::ModelTypeSet preferred_types =
sync_prefs_.GetPreferredDataTypes(registered_directory_types);
-
- return Union(preferred_types, GetDataTypesFromPreferenceProviders());
+ const syncer::ModelTypeSet enforced_types =
+ Intersection(GetDataTypesFromPreferenceProviders(),
+ registered_directory_types);
+ return Union(preferred_types, enforced_types);
}
syncer::ModelTypeSet
return sync_prefs_.GetPreferredDataTypes(GetRegisteredNonBlockingDataTypes());
}
+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 {
return Union(GetRegisteredDirectoryDataTypes(),
GetRegisteredNonBlockingDataTypes());
&directory_data_type_controllers_,
this,
backend_.get(),
- this,
- &failed_data_types_handler_));
+ this));
// We create the migrator at the same time.
migrator_.reset(
return result.release();
}
- FailedDataTypesHandler::TypeErrorMap error_map =
- failed_data_types_handler_.GetAllErrors();
-
+ DataTypeStatusTable::TypeErrorMap error_map =
+ data_type_status_table_.GetAllErrors();
ModelTypeSet active_types;
ModelTypeSet passive_types;
ModelSafeRoutingInfo routing_info;
}
}
-void ProfileSyncService::GoogleSigninSucceeded(const std::string& username,
+void ProfileSyncService::GoogleSigninSucceeded(const std::string& account_id,
+ const std::string& username,
const std::string& password) {
if (!sync_prefs_.IsStartSuppressed() && !password.empty()) {
cached_passphrase_ = password;
}
}
-void ProfileSyncService::GoogleSignedOut(const std::string& username) {
+void ProfileSyncService::GoogleSignedOut(const std::string& account_id,
+ const std::string& username) {
sync_disabled_by_admin_ = false;
DisableForUser();
void ProfileSyncService::UnsuppressAndStart() {
DCHECK(profile_);
sync_prefs_.SetStartSuppressed(false);
- // Set username in SigninManager, as SigninManager::OnGetUserInfoSuccess
- // is never called for some clients.
- if (signin_.get() &&
- signin_->GetOriginal()->GetAuthenticatedUsername().empty()) {
+ if (signin_.get() && !signin_->GetOriginal()->IsAuthenticated()) {
signin_->GetOriginal()->SetAuthenticatedUsername(
profile_->GetPrefs()->GetString(prefs::kGoogleServicesUsername));
}
return types;
}
-const FailedDataTypesHandler& ProfileSyncService::failed_data_types_handler()
+const DataTypeStatusTable& ProfileSyncService::data_type_status_table()
const {
- return failed_data_types_handler_;
+ return data_type_status_table_;
}
void ProfileSyncService::OnInternalUnrecoverableError(
return sessions_sync_manager_.get();
}
+syncer::SyncableService* ProfileSyncService::GetDeviceInfoSyncableService() {
+ return device_info_sync_service_.get();
+}
+
ProfileSyncService::SyncTokenStatus::SyncTokenStatus()
: connection_status(syncer::CONNECTION_NOT_ATTEMPTED),
last_get_token_error(GoogleServiceAuthError::AuthErrorNone()) {}
if (first_sync_time.is_null())
return;
- clear_browsing_data_.Run(profile_, first_sync_time, base::Time::Now());
+ clear_browsing_data_.Run(browsing_data_remover_observer_,
+ profile_,
+ first_sync_time,
+ base::Time::Now());
+}
+
+void ProfileSyncService::SetBrowsingDataRemoverObserverForTesting(
+ BrowsingDataRemover::Observer* observer) {
+ browsing_data_remover_observer_ = observer;
}
void ProfileSyncService::SetClearingBrowseringDataForTesting(
- base::Callback<void(Profile*, base::Time, base::Time)> c) {
+ base::Callback<void(BrowsingDataRemover::Observer* observer,
+ Profile*,
+ base::Time,
+ base::Time)> c) {
clear_browsing_data_ = c;
}
void ProfileSyncService::CheckSyncBackupCallback(base::Time backup_time) {
last_backup_time_.reset(new base::Time(backup_time));
- if (HasSyncingBackend() && backend_initialized_) {
- browser_sync::SyncedDeviceTracker* device_tracker =
- backend_->GetSyncedDeviceTracker();
- if (device_tracker)
- device_tracker->UpdateLocalDeviceBackupTime(*last_backup_time_);
- }
+ DCHECK(device_info_sync_service_);
+ device_info_sync_service_->UpdateLocalDeviceBackupTime(*last_backup_time_);
}
void ProfileSyncService::TryStartSyncAfterBackup() {
}
base::Time ProfileSyncService::GetDeviceBackupTimeForTesting() const {
- return backend_->GetSyncedDeviceTracker()->GetLocalDeviceBackupTime();
+ return device_info_sync_service_->GetLocalDeviceBackupTime();
}
projects / platform / framework / web / crosswalk.git / blobdiff