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

remoting/jingle_glue/jingle_client.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 "remoting/jingle_glue/jingle_client.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "jingle/notifier/communicator/gaia_token_pre_xmpp_auth.h"
 #include "remoting/jingle_glue/iq_request.h"
@@ skipping 14 matching lines @@
 JingleClient::JingleClient(JingleThread* thread)
     : thread_(thread),
       callback_(NULL),
       client_(NULL),
       state_(START),
       initialized_(false),
       closed_(false) {
 }
 
 JingleClient::~JingleClient() {
-  AutoLock auto_lock(state_lock_);
+  base::AutoLock auto_lock(state_lock_);
   DCHECK(!initialized_ || closed_);
 }
 
 void JingleClient::Init(
     const std::string& username, const std::string& auth_token,
     const std::string& auth_token_service, Callback* callback) {
   DCHECK_NE(username, "");
 
   {
-    AutoLock auto_lock(state_lock_);
+    base::AutoLock auto_lock(state_lock_);
     DCHECK(!initialized_ && !closed_);
     initialized_ = true;
 
     DCHECK(callback != NULL);
     callback_ = callback;
   }
 
   message_loop()->PostTask(
       FROM_HERE, NewRunnableMethod(this, &JingleClient::DoInitialize,
                                    username, auth_token, auth_token_service));
@@ skipping 38 matching lines @@
   receiver->EnableOutgoingMessages();
   receiver->Start();
 }
 
 void JingleClient::Close() {
   Close(NULL);
 }
 
 void JingleClient::Close(Task* closed_task) {
   {
-    AutoLock auto_lock(state_lock_);
+    base::AutoLock auto_lock(state_lock_);
     // If the client is already closed then don't close again.
     if (closed_) {
       if (closed_task)
         thread_->message_loop()->PostTask(FROM_HERE, closed_task);
       return;
     }
     closed_task_.reset(closed_task);
     closed_ = true;
   }
 
@@ skipping 15 matching lines @@
     client_ = NULL;
   }
 
   if (closed_task_.get()) {
     closed_task_->Run();
     closed_task_.reset();
   }
 }
 
 std::string JingleClient::GetFullJid() {
-  AutoLock auto_lock(full_jid_lock_);
+  base::AutoLock auto_lock(full_jid_lock_);
   return full_jid_;
 }
 
 IqRequest* JingleClient::CreateIqRequest() {
   return new IqRequest(this);
 }
 
 MessageLoop* JingleClient::message_loop() {
   return thread_->message_loop();
 }
@@ skipping 21 matching lines @@
       // closed. Reset the pointer so we don't try to use it later.
       client_ = NULL;
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 void JingleClient::SetFullJid(const std::string& full_jid) {
-  AutoLock auto_lock(full_jid_lock_);
+  base::AutoLock auto_lock(full_jid_lock_);
   full_jid_ = full_jid;
 }
 
 void JingleClient::UpdateState(State new_state) {
   if (new_state != state_) {
     state_ = new_state;
     {
       // We have to have the lock held, otherwise we cannot be sure that
       // the client hasn't been closed when we call the callback.
-      AutoLock auto_lock(state_lock_);
+      base::AutoLock auto_lock(state_lock_);
       if (!closed_)
         callback_->OnStateChange(this, new_state);
     }
   }
 }
 
 buzz::PreXmppAuth* JingleClient::CreatePreXmppAuth(
     const buzz::XmppClientSettings& settings) {
   buzz::Jid jid(settings.user(), settings.host(), buzz::STR_EMPTY);
   return new notifier::GaiaTokenPreXmppAuth(jid.Str(), settings.auth_cookie(),
                                             settings.token_service());
 }
 
 }  // namespace remoting