Upating the app, ceee, chrome, ipc, media, and net directories to use the correct lock.h file.

chrome/browser/sync/glue/sync_backend_host.cc

 // Copyright (c) 2010 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 "build/build_config.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 135 matching lines @@
   prefs->ScheduleSavePersistentPrefs();
 }
 
 std::string SyncBackendHost::RestoreEncryptionBootstrapToken() {
   PrefService* prefs = profile_->GetPrefs();
   std::string token = prefs->GetString(prefs::kEncryptionBootstrapToken);
   return token;
 }
 
 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.
   return registrar_.routing_info.find(syncable::NIGORI) !=
       registrar_.routing_info.end();
 }
 
 bool SyncBackendHost::IsUsingExplicitPassphrase() {
   return IsNigoriEnabled() && syncapi_initialized_ &&
       core_->syncapi()->InitialSyncEndedForAllEnabledTypes() &&
@@ skipping 150 matching lines @@
   DCHECK(!configure_ready_task_.get());
   DCHECK(syncapi_initialized_);
 
   if (types.count(syncable::AUTOFILL_PROFILE) != 0) {
     ConfigureAutofillMigration();
   }
 
   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) {
       syncable::ModelType type = (*it).first;
 
       // If a type is not specified, remove it from the routing_info.
       if (types.count(type) == 0) {
         registrar_.routing_info.erase(type);
         deleted_type = true;
       } else {
@@ skipping 37 matching lines @@
 }
 
 void SyncBackendHost::RequestNudge() {
   core_thread_.message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(core_.get(), &SyncBackendHost::Core::DoRequestNudge));
 }
 
 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 =
       registrar_.routing_info.find(data_type_controller->type());
   DCHECK(i != registrar_.routing_info.end());
   DCHECK((*i).second == GROUP_PASSIVE);
   syncable::ModelType type = data_type_controller->type();
   // Change the data type's routing info to its group.
   registrar_.routing_info[type] = data_type_controller->model_safe_group();
 
   // Add the data type's change processor to the list of change
   // processors so it can receive updates.
   DCHECK_EQ(processors_.count(type), 0U);
   processors_[type] = change_processor;
 }
 
 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 =
       processors_.erase(data_type_controller->type());
   DCHECK_EQ(erased, 1U);
 
   // TODO(sync): At this point we need to purge the data associated
   // with this data type from the sync db.
 }
 
@@ skipping 82 matching lines @@
 
 const GoogleServiceAuthError& SyncBackendHost::GetAuthError() const {
   return last_auth_error_;
 }
 
 const SyncSessionSnapshot* SyncBackendHost::GetLastSessionSnapshot() const {
   return last_snapshot_.get();
 }
 
 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) {
     out->push_back((*it).second);
   }
 }
 
 void SyncBackendHost::GetModelSafeRoutingInfo(ModelSafeRoutingInfo* out) {
-  AutoLock lock(registrar_lock_);
+  base::AutoLock lock(registrar_lock_);
   ModelSafeRoutingInfo copy(registrar_.routing_info);
   out->swap(copy);
 }
 
 bool SyncBackendHost::HasUnsyncedItems() const {
   DCHECK(syncapi_initialized_);
   return core_->syncapi()->HasUnsyncedItems();
 }
 
 SyncBackendHost::Core::Core(SyncBackendHost* backend)
@@ skipping 225 matching lines @@
 
 void SyncBackendHost::HandleInitializationCompletedOnFrontendLoop() {
   if (!frontend_)
     return;
   syncapi_initialized_ = true;
   frontend_->OnBackendInitialized();
 }
 
 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);
   if (routing_it == host_->registrar_.routing_info.end())
     return false;
   browser_sync::ModelSafeGroup group = routing_it->second;
   WorkerMap::const_iterator worker_it = host_->registrar_.workers.find(group);
   if (worker_it == host_->registrar_.workers.end())
     return false;
   ModelSafeWorker* worker = worker_it->second;
@@ skipping 108 matching lines @@
 }
 
 void SyncBackendHost::Core::DeleteSyncDataFolder() {
   if (file_util::DirectoryExists(host_->sync_data_folder_path())) {
     if (!file_util::Delete(host_->sync_data_folder_path(), true))
       LOG(DFATAL) << "Could not delete the Sync Data folder.";
   }
 }
 
 }  // namespace browser_sync