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

chrome/common/webmessageportchannel_impl.cc

 // Copyright (c) 2009 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 "chrome/common/webmessageportchannel_impl.h"
 
 #include "chrome/common/child_process.h"
 #include "chrome/common/child_thread.h"
 #include "chrome/common/worker_messages.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebString.h"
@@ skipping 35 matching lines @@
 
   if (message_port_id_ != MSG_ROUTING_NONE)
     Send(new WorkerProcessHostMsg_DestroyMessagePort(message_port_id_));
 
   if (route_id_ != MSG_ROUTING_NONE)
     ChildThread::current()->RemoveRoute(route_id_);
 }
 
 void WebMessagePortChannelImpl::setClient(WebMessagePortChannelClient* client) {
   // Must lock here since client_ is called on the main thread.
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   client_ = client;
 }
 
 void WebMessagePortChannelImpl::destroy() {
   setClient(NULL);
 
   // Release the object on the main thread, since the destructor might want to
   // send an IPC, and that has to happen on the main thread.
   ChildThread::current()->message_loop()->ReleaseSoon(FROM_HERE, this);
 }
@@ skipping 31 matching lines @@
   }
 
   IPC::Message* msg = new WorkerProcessHostMsg_PostMessage(
       message_port_id_, message, message_port_ids);
   Send(msg);
 }
 
 bool WebMessagePortChannelImpl::tryGetMessage(
     WebString* message,
     WebMessagePortChannelArray& channels) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   if (message_queue_.empty())
     return false;
 
   *message = message_queue_.front().message;
   const std::vector<WebMessagePortChannelImpl*>& channel_array =
       message_queue_.front().ports;
   WebMessagePortChannelArray result_ports(channel_array.size());
   for (size_t i = 0; i < channel_array.size(); i++) {
     result_ports[i] = channel_array[i];
   }
@@ skipping 68 matching lines @@
     IPC_MESSAGE_HANDLER(WorkerProcessMsg_MessagesQueued, OnMessagedQueued)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void WebMessagePortChannelImpl::OnMessage(
     const string16& message,
     const std::vector<int>& sent_message_port_ids,
     const std::vector<int>& new_routing_ids) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   Message msg;
   msg.message = message;
   if (!sent_message_port_ids.empty()) {
     msg.ports.resize(sent_message_port_ids.size());
     for (size_t i = 0; i < sent_message_port_ids.size(); ++i) {
       msg.ports[i] = new WebMessagePortChannelImpl(
           new_routing_ids[i], sent_message_port_ids[i]);
     }
   }
 
   bool was_empty = message_queue_.empty();
   message_queue_.push(msg);
   if (client_ && was_empty)
     client_->messageAvailable();
 }
 
 void WebMessagePortChannelImpl::OnMessagedQueued() {
   std::vector<QueuedMessage> queued_messages;
 
   {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
     queued_messages.reserve(message_queue_.size());
     while (!message_queue_.empty()) {
       string16 message = message_queue_.front().message;
       const std::vector<WebMessagePortChannelImpl*>& channel_array =
           message_queue_.front().ports;
       std::vector<int> port_ids(channel_array.size());
       for (size_t i = 0; i < channel_array.size(); ++i) {
         port_ids[i] = channel_array[i]->message_port_id();
       }
       queued_messages.push_back(std::make_pair(message, port_ids));
       message_queue_.pop();
     }
   }
 
   Send(new WorkerProcessHostMsg_SendQueuedMessages(
       message_port_id_, queued_messages));
 
   message_port_id_ = MSG_ROUTING_NONE;
 
   Release();
   ChildProcess::current()->ReleaseProcess();
 }
 
 WebMessagePortChannelImpl::Message::Message() {}
 
 WebMessagePortChannelImpl::Message::~Message() {}