diff options
Diffstat (limited to 'chrome/browser/sync')
28 files changed, 93 insertions, 93 deletions
diff --git a/chrome/browser/sync/engine/all_status.cc b/chrome/browser/sync/engine/all_status.cc index 8d4b85e..1580dc4 100644 --- a/chrome/browser/sync/engine/all_status.cc +++ b/chrome/browser/sync/engine/all_status.cc @@ -138,7 +138,7 @@ void AllStatus::HandleServerConnectionEvent( } sync_api::SyncManager::Status AllStatus::status() const { - AutoLock lock(mutex_); + base::AutoLock lock(mutex_); return status_; } diff --git a/chrome/browser/sync/engine/all_status.h b/chrome/browser/sync/engine/all_status.h index 5b2f1d0..015bfb7 100644 --- a/chrome/browser/sync/engine/all_status.h +++ b/chrome/browser/sync/engine/all_status.h @@ -11,8 +11,8 @@ #include <map> -#include "base/lock.h" #include "base/scoped_ptr.h" +#include "base/synchronization/lock.h" #include "chrome/browser/sync/engine/syncapi.h" #include "chrome/browser/sync/engine/syncer_types.h" @@ -57,7 +57,7 @@ class AllStatus : public SyncEngineEventListener { sync_api::SyncManager::Status status_; - mutable Lock mutex_; // Protects all data members. + mutable base::Lock mutex_; // Protects all data members. DISALLOW_COPY_AND_ASSIGN(AllStatus); }; diff --git a/chrome/browser/sync/engine/net/server_connection_manager.cc b/chrome/browser/sync/engine/net/server_connection_manager.cc index 20776fe..7f53a29 100644 --- a/chrome/browser/sync/engine/net/server_connection_manager.cc +++ b/chrome/browser/sync/engine/net/server_connection_manager.cc @@ -255,7 +255,7 @@ bool ServerConnectionManager::CheckServerReachable() { void ServerConnectionManager::kill() { { - AutoLock lock(terminate_all_io_mutex_); + base::AutoLock lock(terminate_all_io_mutex_); terminate_all_io_ = true; } } @@ -294,7 +294,7 @@ void ServerConnectionManager::SetServerParameters(const string& server_url, int port, bool use_ssl) { { - AutoLock lock(server_parameters_mutex_); + base::AutoLock lock(server_parameters_mutex_); sync_server_ = server_url; sync_server_port_ = port; use_ssl_ = use_ssl; @@ -305,7 +305,7 @@ void ServerConnectionManager::SetServerParameters(const string& server_url, void ServerConnectionManager::GetServerParameters(string* server_url, int* port, bool* use_ssl) const { - AutoLock lock(server_parameters_mutex_); + base::AutoLock lock(server_parameters_mutex_); if (server_url != NULL) *server_url = sync_server_; if (port != NULL) diff --git a/chrome/browser/sync/engine/net/server_connection_manager.h b/chrome/browser/sync/engine/net/server_connection_manager.h index 6380151..8921428 100644 --- a/chrome/browser/sync/engine/net/server_connection_manager.h +++ b/chrome/browser/sync/engine/net/server_connection_manager.h @@ -10,8 +10,8 @@ #include <string> #include "base/atomicops.h" -#include "base/lock.h" #include "base/string_util.h" +#include "base/synchronization/lock.h" #include "chrome/browser/sync/syncable/syncable_id.h" #include "chrome/common/deprecated/event_sys.h" #include "chrome/common/deprecated/event_sys-inl.h" @@ -149,7 +149,7 @@ class ScopedServerStatusWatcher { // one instance for every server that you need to talk to. class ServerConnectionManager { public: - typedef EventChannel<ServerConnectionEvent, Lock> Channel; + typedef EventChannel<ServerConnectionEvent, base::Lock> Channel; // buffer_in - will be POSTed // buffer_out - string will be overwritten with response @@ -192,7 +192,7 @@ class ServerConnectionManager { void GetServerParams(std::string* server, int* server_port, bool* use_ssl) const { - AutoLock lock(scm_->server_parameters_mutex_); + base::AutoLock lock(scm_->server_parameters_mutex_); server->assign(scm_->sync_server_); *server_port = scm_->sync_server_port_; *use_ssl = scm_->use_ssl_; @@ -269,7 +269,7 @@ class ServerConnectionManager { std::string GetServerHost() const; bool terminate_all_io() const { - AutoLock lock(terminate_all_io_mutex_); + base::AutoLock lock(terminate_all_io_mutex_); return terminate_all_io_; } @@ -284,23 +284,23 @@ class ServerConnectionManager { void set_auth_token(const std::string& auth_token) { // TODO(chron): Consider adding a message loop check here. - AutoLock lock(auth_token_mutex_); + base::AutoLock lock(auth_token_mutex_); auth_token_.assign(auth_token); } const std::string auth_token() const { - AutoLock lock(auth_token_mutex_); + base::AutoLock lock(auth_token_mutex_); return auth_token_; } protected: inline std::string proto_sync_path() const { - AutoLock lock(path_mutex_); + base::AutoLock lock(path_mutex_); return proto_sync_path_; } std::string get_time_path() const { - AutoLock lock(path_mutex_); + base::AutoLock lock(path_mutex_); return get_time_path_; } @@ -317,7 +317,7 @@ class ServerConnectionManager { ScopedServerStatusWatcher* watcher); // Protects access to sync_server_, sync_server_port_ and use_ssl_: - mutable Lock server_parameters_mutex_; + mutable base::Lock server_parameters_mutex_; // The sync_server_ is the server that requests will be made to. std::string sync_server_; @@ -335,15 +335,15 @@ class ServerConnectionManager { bool use_ssl_; // The paths we post to. - mutable Lock path_mutex_; + mutable base::Lock path_mutex_; std::string proto_sync_path_; std::string get_time_path_; - mutable Lock auth_token_mutex_; + mutable base::Lock auth_token_mutex_; // The auth token to use in authenticated requests. Set by the AuthWatcher. std::string auth_token_; - Lock error_count_mutex_; // Protects error_count_ + base::Lock error_count_mutex_; // Protects error_count_ int error_count_; // Tracks the number of connection errors. Channel* const channel_; @@ -363,7 +363,7 @@ class ServerConnectionManager { void NotifyStatusChanged(); void ResetConnection(); - mutable Lock terminate_all_io_mutex_; + mutable base::Lock terminate_all_io_mutex_; bool terminate_all_io_; // When set to true, terminate all connections asap. DISALLOW_COPY_AND_ASSIGN(ServerConnectionManager); }; diff --git a/chrome/browser/sync/engine/syncapi.cc b/chrome/browser/sync/engine/syncapi.cc index 7725afd..bc11b31 100644 --- a/chrome/browser/sync/engine/syncapi.cc +++ b/chrome/browser/sync/engine/syncapi.cc @@ -11,12 +11,12 @@ #include <vector> #include "base/base64.h" -#include "base/lock.h" #include "base/logging.h" #include "base/message_loop.h" #include "base/scoped_ptr.h" #include "base/sha1.h" #include "base/string_util.h" +#include "base/synchronization/lock.h" #include "base/task.h" #include "base/utf_string_conversions.h" #include "chrome/browser/browser_thread.h" @@ -1070,7 +1070,7 @@ class SyncManager::SyncInternal // Whether we're initialized to the point of being able to accept changes // (and hence allow transaction creation). See initialized_ for details. bool initialized() const { - AutoLock lock(initialized_mutex_); + base::AutoLock lock(initialized_mutex_); return initialized_; } @@ -1310,7 +1310,7 @@ class SyncManager::SyncInternal // meaning we are ready to accept changes. Protected by initialized_mutex_ // as it can get read/set by both the SyncerThread and the AuthWatcherThread. bool initialized_; - mutable Lock initialized_mutex_; + mutable base::Lock initialized_mutex_; notifier::NotifierOptions notifier_options_; @@ -1531,7 +1531,7 @@ void SyncManager::SyncInternal::MarkAndNotifyInitializationComplete() { // between their respective threads to call MarkAndNotify. We need to make // sure the observer is notified once and only once. { - AutoLock lock(initialized_mutex_); + base::AutoLock lock(initialized_mutex_); if (initialized_) return; initialized_ = true; diff --git a/chrome/browser/sync/engine/syncer.cc b/chrome/browser/sync/engine/syncer.cc index cbf9753..70d585f 100644 --- a/chrome/browser/sync/engine/syncer.cc +++ b/chrome/browser/sync/engine/syncer.cc @@ -62,12 +62,12 @@ Syncer::Syncer() Syncer::~Syncer() {} bool Syncer::ExitRequested() { - AutoLock lock(early_exit_requested_lock_); + base::AutoLock lock(early_exit_requested_lock_); return early_exit_requested_; } void Syncer::RequestEarlyExit() { - AutoLock lock(early_exit_requested_lock_); + base::AutoLock lock(early_exit_requested_lock_); early_exit_requested_ = true; } diff --git a/chrome/browser/sync/engine/syncer.h b/chrome/browser/sync/engine/syncer.h index 2789ed2..89f1307 100644 --- a/chrome/browser/sync/engine/syncer.h +++ b/chrome/browser/sync/engine/syncer.h @@ -12,8 +12,8 @@ #include "base/basictypes.h" #include "base/callback.h" #include "base/gtest_prod_util.h" -#include "base/lock.h" #include "base/scoped_ptr.h" +#include "base/synchronization/lock.h" #include "chrome/browser/sync/engine/conflict_resolver.h" #include "chrome/browser/sync/engine/syncer_types.h" #include "chrome/browser/sync/engine/syncproto.h" @@ -109,7 +109,7 @@ class Syncer { SyncerStep last_step); bool early_exit_requested_; - Lock early_exit_requested_lock_; + base::Lock early_exit_requested_lock_; int32 max_commit_batch_size_; diff --git a/chrome/browser/sync/engine/syncer_thread.cc b/chrome/browser/sync/engine/syncer_thread.cc index e9a3a20..8813709 100644 --- a/chrome/browser/sync/engine/syncer_thread.cc +++ b/chrome/browser/sync/engine/syncer_thread.cc @@ -556,7 +556,7 @@ SyncSession* SyncerThread::SyncMain(Syncer* syncer, bool was_throttled, continue_sync_cycle, initial_sync_for_thread, was_nudged)); scoped_ptr<SyncSession> session; - AutoUnlock unlock(lock_); + base::AutoUnlock unlock(lock_); do { session.reset(new SyncSession(session_context_.get(), this, info, routes, workers)); diff --git a/chrome/browser/sync/engine/syncer_thread_unittest.cc b/chrome/browser/sync/engine/syncer_thread_unittest.cc index 4b13e8f..1553e9c 100644 --- a/chrome/browser/sync/engine/syncer_thread_unittest.cc +++ b/chrome/browser/sync/engine/syncer_thread_unittest.cc @@ -5,8 +5,8 @@ #include <list> #include <map> -#include "base/lock.h" #include "base/scoped_ptr.h" +#include "base/synchronization/lock.h" #include "base/time.h" #include "base/synchronization/waitable_event.h" #include "chrome/browser/sync/engine/model_safe_worker.h" @@ -125,7 +125,7 @@ class SyncerThreadWithSyncerTest : public testing::Test, void WaitForDisconnect() { // Wait for the SyncerThread to detect loss of connection, up to a max of // 10 seconds to timeout the test. - AutoLock lock(syncer_thread()->lock_); + base::AutoLock lock(syncer_thread()->lock_); TimeTicks start = TimeTicks::Now(); TimeDelta ten_seconds = TimeDelta::FromSeconds(10); while (syncer_thread()->vault_.connected_) { @@ -139,7 +139,7 @@ class SyncerThreadWithSyncerTest : public testing::Test, bool Pause(ListenerMock* listener) { WaitableEvent event(false, false); { - AutoLock lock(syncer_thread()->lock_); + base::AutoLock lock(syncer_thread()->lock_); EXPECT_CALL(*listener, OnSyncEngineEvent( Field(&SyncEngineEvent::what_happened, SyncEngineEvent::SYNCER_THREAD_PAUSED))). @@ -153,7 +153,7 @@ class SyncerThreadWithSyncerTest : public testing::Test, bool Resume(ListenerMock* listener) { WaitableEvent event(false, false); { - AutoLock lock(syncer_thread()->lock_); + base::AutoLock lock(syncer_thread()->lock_); EXPECT_CALL(*listener, OnSyncEngineEvent( Field(&SyncEngineEvent::what_happened, SyncEngineEvent::SYNCER_THREAD_RESUMED))). @@ -330,7 +330,7 @@ TEST_F(SyncerThreadTest, CalculatePollingWaitTime) { scoped_refptr<SyncerThread> syncer_thread(new SyncerThread(context)); syncer_thread->DisableIdleDetection(); // Hold the lock to appease asserts in code. - AutoLock lock(syncer_thread->lock_); + base::AutoLock lock(syncer_thread->lock_); // Notifications disabled should result in a polling interval of // kDefaultShortPollInterval. diff --git a/chrome/browser/sync/glue/autofill_data_type_controller.cc b/chrome/browser/sync/glue/autofill_data_type_controller.cc index 8661e14..1c57df2 100644 --- a/chrome/browser/sync/glue/autofill_data_type_controller.cc +++ b/chrome/browser/sync/glue/autofill_data_type_controller.cc @@ -109,7 +109,7 @@ void AutofillDataTypeController::Stop() { // thread to finish the StartImpl() task. if (state_ == ASSOCIATING) { { - AutoLock lock(abort_association_lock_); + base::AutoLock lock(abort_association_lock_); abort_association_ = true; if (model_associator_.get()) model_associator_->AbortAssociation(); @@ -189,7 +189,7 @@ void AutofillDataTypeController::StartImpl() { // No additional services need to be started before we can proceed // with model association. { - AutoLock lock(abort_association_lock_); + base::AutoLock lock(abort_association_lock_); if (abort_association_) { abort_association_complete_.Signal(); return; @@ -232,7 +232,7 @@ void AutofillDataTypeController::StartDone( DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB)); abort_association_complete_.Signal(); - AutoLock lock(abort_association_lock_); + base::AutoLock lock(abort_association_lock_); if (!abort_association_) { BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, NewRunnableMethod( diff --git a/chrome/browser/sync/glue/autofill_data_type_controller.h b/chrome/browser/sync/glue/autofill_data_type_controller.h index 2daedb42..05b964c 100644 --- a/chrome/browser/sync/glue/autofill_data_type_controller.h +++ b/chrome/browser/sync/glue/autofill_data_type_controller.h @@ -101,7 +101,7 @@ class AutofillDataTypeController : public DataTypeController, NotificationRegistrar notification_registrar_; - Lock abort_association_lock_; + base::Lock abort_association_lock_; bool abort_association_; base::WaitableEvent abort_association_complete_; diff --git a/chrome/browser/sync/glue/autofill_model_associator.cc b/chrome/browser/sync/glue/autofill_model_associator.cc index 43e4db6..14b9f2b 100644 --- a/chrome/browser/sync/glue/autofill_model_associator.cc +++ b/chrome/browser/sync/glue/autofill_model_associator.cc @@ -136,7 +136,7 @@ bool AutofillModelAssociator::AssociateModels() { VLOG(1) << "Associating Autofill Models"; DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB)); { - AutoLock lock(abort_association_pending_lock_); + base::AutoLock lock(abort_association_pending_lock_); abort_association_pending_ = false; } @@ -401,7 +401,7 @@ bool AutofillModelAssociator::SyncModelHasUserCreatedNodes(bool* has_nodes) { void AutofillModelAssociator::AbortAssociation() { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); - AutoLock lock(abort_association_pending_lock_); + base::AutoLock lock(abort_association_pending_lock_); abort_association_pending_ = true; } @@ -454,7 +454,7 @@ bool AutofillModelAssociator::GetSyncIdForTaggedNode(const std::string& tag, } bool AutofillModelAssociator::IsAbortPending() { - AutoLock lock(abort_association_pending_lock_); + base::AutoLock lock(abort_association_pending_lock_); return abort_association_pending_; } diff --git a/chrome/browser/sync/glue/autofill_model_associator.h b/chrome/browser/sync/glue/autofill_model_associator.h index fb660e6..a0eee27 100644 --- a/chrome/browser/sync/glue/autofill_model_associator.h +++ b/chrome/browser/sync/glue/autofill_model_associator.h @@ -12,8 +12,8 @@ #include <vector> #include "base/basictypes.h" -#include "base/lock.h" #include "base/ref_counted.h" +#include "base/synchronization/lock.h" #include "chrome/browser/autofill/personal_data_manager.h" #include "chrome/browser/sync/engine/syncapi.h" #include "chrome/browser/sync/glue/model_associator.h" @@ -183,7 +183,7 @@ class AutofillModelAssociator // Abort association pending flag and lock. If this is set to true // (via the AbortAssociation method), return from the // AssociateModels method as soon as possible. - Lock abort_association_pending_lock_; + base::Lock abort_association_pending_lock_; bool abort_association_pending_; int number_of_entries_created_; diff --git a/chrome/browser/sync/glue/autofill_profile_model_associator.cc b/chrome/browser/sync/glue/autofill_profile_model_associator.cc index c517e2c..d6a6792 100644 --- a/chrome/browser/sync/glue/autofill_profile_model_associator.cc +++ b/chrome/browser/sync/glue/autofill_profile_model_associator.cc @@ -129,7 +129,7 @@ bool AutofillProfileModelAssociator::AssociateModels() { VLOG(1) << "Associating Autofill Models"; DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB)); { - AutoLock lock(abort_association_pending_lock_); + base::AutoLock lock(abort_association_pending_lock_); abort_association_pending_ = false; } @@ -458,7 +458,7 @@ int64 AutofillProfileModelAssociator::GetSyncIdFromChromeId( void AutofillProfileModelAssociator::AbortAssociation() { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); - AutoLock lock(abort_association_pending_lock_); + base::AutoLock lock(abort_association_pending_lock_); abort_association_pending_ = true; } @@ -469,7 +469,7 @@ const std::string* AutofillProfileModelAssociator::GetChromeNodeFromSyncId( } bool AutofillProfileModelAssociator::IsAbortPending() { - AutoLock lock(abort_association_pending_lock_); + base::AutoLock lock(abort_association_pending_lock_); return abort_association_pending_; } diff --git a/chrome/browser/sync/glue/autofill_profile_model_associator.h b/chrome/browser/sync/glue/autofill_profile_model_associator.h index e2abdaf..3286283 100644 --- a/chrome/browser/sync/glue/autofill_profile_model_associator.h +++ b/chrome/browser/sync/glue/autofill_profile_model_associator.h @@ -12,8 +12,8 @@ #include <vector> #include "base/basictypes.h" -#include "base/lock.h" #include "base/ref_counted.h" +#include "base/synchronization/lock.h" #include "chrome/browser/autofill/personal_data_manager.h" #include "chrome/browser/sync/engine/syncapi.h" #include "chrome/browser/sync/glue/model_associator.h" @@ -175,7 +175,7 @@ class AutofillProfileModelAssociator // Abort association pending flag and lock. If this is set to true // (via the AbortAssociation method), return from the // AssociateModels method as soon as possible. - Lock abort_association_pending_lock_; + base::Lock abort_association_pending_lock_; bool abort_association_pending_; int number_of_profiles_created_; diff --git a/chrome/browser/sync/glue/password_model_associator.cc b/chrome/browser/sync/glue/password_model_associator.cc index 3c9d01a..d6708b5 100644 --- a/chrome/browser/sync/glue/password_model_associator.cc +++ b/chrome/browser/sync/glue/password_model_associator.cc @@ -41,7 +41,7 @@ PasswordModelAssociator::~PasswordModelAssociator() {} bool PasswordModelAssociator::AssociateModels() { DCHECK(expected_loop_ == MessageLoop::current()); { - AutoLock lock(abort_association_pending_lock_); + base::AutoLock lock(abort_association_pending_lock_); abort_association_pending_ = false; } @@ -194,7 +194,7 @@ bool PasswordModelAssociator::SyncModelHasUserCreatedNodes(bool* has_nodes) { void PasswordModelAssociator::AbortAssociation() { DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); - AutoLock lock(abort_association_pending_lock_); + base::AutoLock lock(abort_association_pending_lock_); abort_association_pending_ = true; } @@ -210,7 +210,7 @@ bool PasswordModelAssociator::InitSyncNodeFromChromeId( } bool PasswordModelAssociator::IsAbortPending() { - AutoLock lock(abort_association_pending_lock_); + base::AutoLock lock(abort_association_pending_lock_); return abort_association_pending_; } diff --git a/chrome/browser/sync/glue/password_model_associator.h b/chrome/browser/sync/glue/password_model_associator.h index 15eb3724..cfe0dab 100644 --- a/chrome/browser/sync/glue/password_model_associator.h +++ b/chrome/browser/sync/glue/password_model_associator.h @@ -11,7 +11,7 @@ #include <vector> #include "base/basictypes.h" -#include "base/lock.h" +#include "base/synchronization/lock.h" #include "base/task.h" #include "chrome/browser/history/history_types.h" #include "chrome/browser/sync/glue/model_associator.h" @@ -132,7 +132,7 @@ class PasswordModelAssociator // Abort association pending flag and lock. If this is set to true // (via the AbortAssociation method), return from the // AssociateModels method as soon as possible. - Lock abort_association_pending_lock_; + base::Lock abort_association_pending_lock_; bool abort_association_pending_; MessageLoop* expected_loop_; diff --git a/chrome/browser/sync/glue/sync_backend_host.cc b/chrome/browser/sync/glue/sync_backend_host.cc index 62b9aae..3e600e1 100644 --- a/chrome/browser/sync/glue/sync_backend_host.cc +++ b/chrome/browser/sync/glue/sync_backend_host.cc @@ -156,7 +156,7 @@ std::string SyncBackendHost::RestoreEncryptionBootstrapToken() { } bool SyncBackendHost::IsNigoriEnabled() const { - AutoLock lock(registrar_lock_); + base::AutoLock lock(registrar_lock_); // Note that NIGORI is only ever added/removed from routing_info once, // during initialization / first configuration, so there is no real 'race' // possible here or possibility of stale return value. @@ -333,7 +333,7 @@ void SyncBackendHost::ConfigureDataTypes( bool deleted_type = false; { - AutoLock lock(registrar_lock_); + base::AutoLock lock(registrar_lock_); for (DataTypeController::TypeMap::const_iterator it = data_type_controllers.begin(); it != data_type_controllers.end(); ++it) { @@ -391,7 +391,7 @@ void SyncBackendHost::RequestNudge() { void SyncBackendHost::ActivateDataType( DataTypeController* data_type_controller, ChangeProcessor* change_processor) { - AutoLock lock(registrar_lock_); + base::AutoLock lock(registrar_lock_); // Ensure that the given data type is in the PASSIVE group. browser_sync::ModelSafeRoutingInfo::iterator i = @@ -411,7 +411,7 @@ void SyncBackendHost::ActivateDataType( void SyncBackendHost::DeactivateDataType( DataTypeController* data_type_controller, ChangeProcessor* change_processor) { - AutoLock lock(registrar_lock_); + base::AutoLock lock(registrar_lock_); registrar_.routing_info.erase(data_type_controller->type()); std::map<syncable::ModelType, ChangeProcessor*>::size_type erased = @@ -516,7 +516,7 @@ const SyncSessionSnapshot* SyncBackendHost::GetLastSessionSnapshot() const { } void SyncBackendHost::GetWorkers(std::vector<ModelSafeWorker*>* out) { - AutoLock lock(registrar_lock_); + base::AutoLock lock(registrar_lock_); out->clear(); for (WorkerMap::const_iterator it = registrar_.workers.begin(); it != registrar_.workers.end(); ++it) { @@ -525,7 +525,7 @@ void SyncBackendHost::GetWorkers(std::vector<ModelSafeWorker*>* out) { } void SyncBackendHost::GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) { - AutoLock lock(registrar_lock_); + base::AutoLock lock(registrar_lock_); ModelSafeRoutingInfo copy(registrar_.routing_info); out->swap(copy); } @@ -771,7 +771,7 @@ void SyncBackendHost::HandleInitializationCompletedOnFrontendLoop() { bool SyncBackendHost::Core::IsCurrentThreadSafeForModel( syncable::ModelType model_type) { - AutoLock lock(host_->registrar_lock_); + base::AutoLock lock(host_->registrar_lock_); browser_sync::ModelSafeRoutingInfo::const_iterator routing_it = host_->registrar_.routing_info.find(model_type); diff --git a/chrome/browser/sync/glue/sync_backend_host.h b/chrome/browser/sync/glue/sync_backend_host.h index cd418aa..964f7a5 100644 --- a/chrome/browser/sync/glue/sync_backend_host.h +++ b/chrome/browser/sync/glue/sync_backend_host.h @@ -11,9 +11,9 @@ #include <vector> #include "base/file_path.h" -#include "base/lock.h" #include "base/message_loop.h" #include "base/ref_counted.h" +#include "base/synchronization/lock.h" #include "base/threading/thread.h" #include "base/timer.h" #include "base/utf_string_conversions.h" @@ -507,7 +507,7 @@ class SyncBackendHost : public browser_sync::ModelSafeWorkerRegistrar { // pointer value", and then invoke methods), because lifetimes are managed on // the UI thread. Of course, this comment only applies to ModelSafeWorker // impls that are themselves thread-safe, such as UIModelWorker. - mutable Lock registrar_lock_; + mutable base::Lock registrar_lock_; // The frontend which we serve (and are owned by). SyncFrontend* frontend_; diff --git a/chrome/browser/sync/syncable/directory_manager.cc b/chrome/browser/sync/syncable/directory_manager.cc index fbdeb46..989fd0e 100644 --- a/chrome/browser/sync/syncable/directory_manager.cc +++ b/chrome/browser/sync/syncable/directory_manager.cc @@ -44,7 +44,7 @@ DirectoryManager::DirectoryManager(const FilePath& path) } DirectoryManager::~DirectoryManager() { - AutoLock lock(lock_); + base::AutoLock lock(lock_); DCHECK_EQ(managed_directory_, static_cast<Directory*>(NULL)) << "Dir " << managed_directory_->name() << " not closed!"; delete channel_; @@ -63,7 +63,7 @@ DirOpenResult DirectoryManager::OpenImpl(const std::string& name, bool* was_open) { bool opened = false; { - AutoLock lock(lock_); + base::AutoLock lock(lock_); // Check to see if it's already open. if (managed_directory_) { DCHECK_EQ(ComparePathNames(name, managed_directory_->name()), 0) @@ -79,7 +79,7 @@ DirOpenResult DirectoryManager::OpenImpl(const std::string& name, scoped_ptr<Directory> dir(new Directory); const DirOpenResult result = dir->Open(path, name); if (syncable::OPENED == result) { - AutoLock lock(lock_); + base::AutoLock lock(lock_); managed_directory_ = dir.release(); } return result; @@ -90,7 +90,7 @@ DirOpenResult DirectoryManager::OpenImpl(const std::string& name, void DirectoryManager::Close(const std::string& name) { // Erase from mounted and opened directory lists. { - AutoLock lock(lock_); + base::AutoLock lock(lock_); if (!managed_directory_ || ComparePathNames(name, managed_directory_->name()) != 0) { // It wasn't open. @@ -109,14 +109,14 @@ void DirectoryManager::Close(const std::string& name) { } void DirectoryManager::FinalSaveChangesForAll() { - AutoLock lock(lock_); + base::AutoLock lock(lock_); if (managed_directory_) managed_directory_->SaveChanges(); } void DirectoryManager::GetOpenDirectories(DirNames* result) { result->clear(); - AutoLock lock(lock_); + base::AutoLock lock(lock_); if (managed_directory_) result->push_back(managed_directory_->name()); } diff --git a/chrome/browser/sync/syncable/directory_manager.h b/chrome/browser/sync/syncable/directory_manager.h index 0c0b55d..625d082 100644 --- a/chrome/browser/sync/syncable/directory_manager.h +++ b/chrome/browser/sync/syncable/directory_manager.h @@ -18,7 +18,7 @@ #include "base/basictypes.h" #include "base/file_path.h" -#include "base/lock.h" +#include "base/synchronization/lock.h" #include "chrome/browser/sync/syncable/dir_open_result.h" #include "chrome/browser/sync/syncable/path_name_cmp.h" #include "chrome/browser/sync/syncable/syncable.h" @@ -87,7 +87,7 @@ class DirectoryManager { const FilePath root_path_; // protects managed_directory_ - Lock lock_; + base::Lock lock_; Directory* managed_directory_; Channel* const channel_; diff --git a/chrome/browser/sync/syncable/syncable.cc b/chrome/browser/sync/syncable/syncable.cc index 93ca8bb..83053fa 100644 --- a/chrome/browser/sync/syncable/syncable.cc +++ b/chrome/browser/sync/syncable/syncable.cc @@ -586,7 +586,7 @@ bool Directory::SaveChanges() { bool success = false; DCHECK(store_); - AutoLock scoped_lock(kernel_->save_changes_mutex); + base::AutoLock scoped_lock(kernel_->save_changes_mutex); // Snapshot and save. SaveChangesSnapshot snapshot; @@ -1141,7 +1141,7 @@ bool BaseTransaction::NotifyTransactionChangingAndEnding( { // Scoped_lock is only active through the calculate_changes and // transaction_ending events. - AutoLock scoped_lock(dirkernel_->changes_channel_mutex); + base::AutoLock scoped_lock(dirkernel_->changes_channel_mutex); // Tell listeners to calculate changes while we still have the mutex. DirectoryChangeEvent event = { DirectoryChangeEvent::CALCULATE_CHANGES, diff --git a/chrome/browser/sync/syncable/syncable.h b/chrome/browser/sync/syncable/syncable.h index d3b7527..4e1b0b9 100644 --- a/chrome/browser/sync/syncable/syncable.h +++ b/chrome/browser/sync/syncable/syncable.h @@ -18,7 +18,7 @@ #include "base/basictypes.h" #include "base/file_path.h" #include "base/gtest_prod_util.h" -#include "base/lock.h" +#include "base/synchronization/lock.h" #include "base/time.h" #include "chrome/browser/sync/protocol/sync.pb.h" #include "chrome/browser/sync/syncable/autofill_migration.h" @@ -807,7 +807,7 @@ class Directory { } }; public: - typedef EventChannel<DirectoryEventTraits, Lock> Channel; + typedef EventChannel<DirectoryEventTraits, base::Lock> Channel; typedef std::vector<int64> ChildHandles; // Returns the child meta handles for given parent id. @@ -960,7 +960,7 @@ class Directory { volatile base::subtle::AtomicWord refcount; // Implements ReadTransaction / WriteTransaction using a simple lock. - Lock transaction_mutex; + base::Lock transaction_mutex; // The name of this directory. std::string const name; @@ -972,7 +972,7 @@ class Directory { // // Never hold the mutex and do anything with the database or any // other buffered IO. Violating this rule will result in deadlock. - Lock mutex; + base::Lock mutex; MetahandlesIndex* metahandles_index; // Entries indexed by metahandle IdsIndex* ids_index; // Entries indexed by id ParentIdChildIndex* parent_id_child_index; @@ -1000,7 +1000,7 @@ class Directory { // releasing the transaction mutex. browser_sync::Channel<DirectoryChangeEvent> changes_channel; - Lock changes_channel_mutex; + base::Lock changes_channel_mutex; KernelShareInfoStatus info_status; // These 3 members are backed in the share_info table, and @@ -1016,7 +1016,7 @@ class Directory { // It doesn't make sense for two threads to run SaveChanges at the same // time; this mutex protects that activity. - Lock save_changes_mutex; + base::Lock save_changes_mutex; // The next metahandle is protected by kernel mutex. int64 next_metahandle; @@ -1036,7 +1036,7 @@ class ScopedKernelLock { explicit ScopedKernelLock(const Directory*); ~ScopedKernelLock() {} - AutoLock scoped_lock_; + base::AutoLock scoped_lock_; Directory* const dir_; DISALLOW_COPY_AND_ASSIGN(ScopedKernelLock); }; diff --git a/chrome/browser/sync/util/channel.h b/chrome/browser/sync/util/channel.h index 88ddfc4..839d653 100644 --- a/chrome/browser/sync/util/channel.h +++ b/chrome/browser/sync/util/channel.h @@ -50,8 +50,8 @@ // /////////////////////////////////////////////////////////////////////////////// -#include "base/lock.h" #include "base/observer_list.h" +#include "base/synchronization/lock.h" #include "base/threading/platform_thread.h" namespace browser_sync { @@ -98,7 +98,7 @@ class Channel { ChannelHookup<EventType>* AddObserver( ChannelEventHandler<EventType>* observer) { - AutoLock scoped_lock(event_handlers_mutex_); + base::AutoLock scoped_lock(event_handlers_mutex_); event_handlers_.AddObserver(observer); return new ChannelHookup<EventType>(this, observer); } @@ -117,7 +117,7 @@ class Channel { } void Notify(const EventType& event) { - AutoLock scoped_lock(event_handlers_mutex_); + base::AutoLock scoped_lock(event_handlers_mutex_); // This may result in an observer trying to remove itself, so keep track // of the thread we're locked on. @@ -135,7 +135,7 @@ class Channel { } private: - Lock event_handlers_mutex_; + base::Lock event_handlers_mutex_; base::PlatformThreadId locking_thread_; ObserverList<EventHandler> event_handlers_; }; diff --git a/chrome/browser/sync/util/extensions_activity_monitor.cc b/chrome/browser/sync/util/extensions_activity_monitor.cc index aad4ab6..8c7a52a 100644 --- a/chrome/browser/sync/util/extensions_activity_monitor.cc +++ b/chrome/browser/sync/util/extensions_activity_monitor.cc @@ -65,13 +65,13 @@ ExtensionsActivityMonitor::~ExtensionsActivityMonitor() { } void ExtensionsActivityMonitor::GetAndClearRecords(Records* buffer) { - AutoLock lock(records_lock_); + base::AutoLock lock(records_lock_); buffer->clear(); buffer->swap(records_); } void ExtensionsActivityMonitor::PutRecords(const Records& records) { - AutoLock lock(records_lock_); + base::AutoLock lock(records_lock_); for (Records::const_iterator i = records.begin(); i != records.end(); ++i) { records_[i->first].extension_id = i->second.extension_id; records_[i->first].bookmark_write_count += i->second.bookmark_write_count; @@ -81,7 +81,7 @@ void ExtensionsActivityMonitor::PutRecords(const Records& records) { void ExtensionsActivityMonitor::Observe(NotificationType type, const NotificationSource& source, const NotificationDetails& details) { - AutoLock lock(records_lock_); + base::AutoLock lock(records_lock_); DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); const Extension* extension = Source<const Extension>(source).ptr(); const BookmarksFunction* f = Details<const BookmarksFunction>(details).ptr(); diff --git a/chrome/browser/sync/util/extensions_activity_monitor.h b/chrome/browser/sync/util/extensions_activity_monitor.h index f4d1037..f19090d 100644 --- a/chrome/browser/sync/util/extensions_activity_monitor.h +++ b/chrome/browser/sync/util/extensions_activity_monitor.h @@ -8,8 +8,8 @@ #include <map> -#include "base/lock.h" #include "base/message_loop.h" +#include "base/synchronization/lock.h" #include "chrome/common/notification_observer.h" #include "chrome/common/notification_registrar.h" @@ -62,7 +62,7 @@ class ExtensionsActivityMonitor : public NotificationObserver { const NotificationDetails& details); private: Records records_; - mutable Lock records_lock_; + mutable base::Lock records_lock_; // Used only from UI loop. NotificationRegistrar registrar_; diff --git a/chrome/browser/sync/util/user_settings.cc b/chrome/browser/sync/util/user_settings.cc index 9f52088..d49a071 100644 --- a/chrome/browser/sync/util/user_settings.cc +++ b/chrome/browser/sync/util/user_settings.cc @@ -79,7 +79,7 @@ UserSettings::UserSettings() : dbhandle_(NULL) { } string UserSettings::email() const { - AutoLock lock(mutex_); + base::AutoLock lock(mutex_); return email_; } @@ -421,7 +421,7 @@ bool UserSettings::VerifyAgainstStoredHash(const string& email, void UserSettings::SwitchUser(const string& username) { { - AutoLock lock(mutex_); + base::AutoLock lock(mutex_); email_ = username; } } diff --git a/chrome/browser/sync/util/user_settings.h b/chrome/browser/sync/util/user_settings.h index 5545c8c..546c8b0 100644 --- a/chrome/browser/sync/util/user_settings.h +++ b/chrome/browser/sync/util/user_settings.h @@ -9,7 +9,7 @@ #include <map> #include <string> -#include "base/lock.h" +#include "base/synchronization/lock.h" #include "build/build_config.h" extern "C" struct sqlite3; @@ -79,7 +79,7 @@ class UserSettings { struct ScopedDBHandle { explicit ScopedDBHandle(UserSettings* settings); inline sqlite3* get() const { return *handle_; } - AutoLock mutex_lock_; + base::AutoLock mutex_lock_; sqlite3** const handle_; }; @@ -90,11 +90,11 @@ class UserSettings { private: std::string email_; - mutable Lock mutex_; // protects email_. + mutable base::Lock mutex_; // protects email_. // We keep a single dbhandle. sqlite3* dbhandle_; - Lock dbhandle_mutex_; + base::Lock dbhandle_mutex_; // TODO(sync): Use in-memory cache for service auth tokens on posix. // Have someone competent in Windows switch it over to not use Sqlite in the |