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

webkit/glue/media/buffered_data_source.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 "webkit/glue/media/buffered_data_source.h"
 
 #include "media/base/filter_host.h"
 #include "net/base/net_errors.h"
 #include "webkit/glue/webkit_glue.h"
 
@@ skipping 97 matching lines @@
 
 bool BufferedDataSource::IsUrlSupported(const std::string& url) {
   GURL gurl(url);
 
   // This data source doesn't support data:// protocol so reject it.
   return IsProtocolSupportedForMedia(gurl) && !gurl.SchemeIs(kDataScheme);
 }
 
 void BufferedDataSource::Stop(media::FilterCallback* callback) {
   {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
     stop_signal_received_ = true;
   }
   if (callback) {
     callback->Run();
     delete callback;
   }
 
   render_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &BufferedDataSource::CleanupTask));
 }
@@ skipping 30 matching lines @@
   DCHECK(MessageLoop::current() == render_loop_);
   return single_origin_;
 }
 
 void BufferedDataSource::Abort() {
   DCHECK(MessageLoop::current() == render_loop_);
 
   // If we are told to abort, immediately return from any pending read
   // with an error.
   if (read_callback_.get()) {
-      AutoLock auto_lock(lock_);
+      base::AutoLock auto_lock(lock_);
       DoneRead_Locked(net::ERR_FAILED);
   }
 
   CleanupTask();
   frame_ = NULL;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // Render thread tasks.
 void BufferedDataSource::InitializeTask() {
@@ skipping 227 matching lines @@
   }
 
   // We need to prevent calling to filter host and running the callback if
   // we have received the stop signal. We need to lock down the whole callback
   // method to prevent bad things from happening. The reason behind this is
   // that we cannot guarantee tasks on render thread have completely stopped
   // when we receive the Stop() method call. The only way to solve this is to
   // let tasks on render thread to run but make sure they don't call outside
   // this object when Stop() method is ever called. Locking this method is safe
   // because |lock_| is only acquired in tasks on render thread.
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   if (stop_signal_received_)
     return;
 
   if (!success) {
     host()->SetError(media::PIPELINE_ERROR_NETWORK);
     DoneInitialization_Locked();
     return;
   }
 
   if (streaming_) {
@@ skipping 30 matching lines @@
   }
 
   // We need to prevent calling to filter host and running the callback if
   // we have received the stop signal. We need to lock down the whole callback
   // method to prevent bad things from happening. The reason behind this is
   // that we cannot guarantee tasks on render thread have completely stopped
   // when we receive the Stop() method call. The only way to solve this is to
   // let tasks on render thread to run but make sure they don't call outside
   // this object when Stop() method is ever called. Locking this method is safe
   // because |lock_| is only acquired in tasks on render thread.
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   if (stop_signal_received_)
     return;
 
   if (success) {
     host()->SetTotalBytes(total_bytes_);
     host()->SetBufferedBytes(total_bytes_);
     host()->SetLoaded(loaded_);
   } else {
     host()->SetError(media::PIPELINE_ERROR_NETWORK);
   }
@@ skipping 18 matching lines @@
   loader_->Stop();
 
   // We need to prevent calling to filter host and running the callback if
   // we have received the stop signal. We need to lock down the whole callback
   // method to prevent bad things from happening. The reason behind this is
   // that we cannot guarantee tasks on render thread have completely stopped
   // when we receive the Stop() method call. So only way to solve this is to
   // let tasks on render thread to run but make sure they don't call outside
   // this object when Stop() method is ever called. Locking this method is
   // safe because |lock_| is only acquired in tasks on render thread.
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   if (stop_signal_received_)
     return;
   DoneRead_Locked(net::ERR_INVALID_RESPONSE);
 }
 
 void BufferedDataSource::ReadCallback(int error) {
   DCHECK(MessageLoop::current() == render_loop_);
 
   if (error < 0) {
     DCHECK(loader_.get());
 
     // Stop the resource load if it failed.
     loader_->Stop();
 
     if (error == net::ERR_CACHE_MISS) {
       render_loop_->PostTask(FROM_HERE,
           NewRunnableMethod(this, &BufferedDataSource::RestartLoadingTask));
       return;
     }
   }
 
   // We need to prevent calling to filter host and running the callback if
   // we have received the stop signal. We need to lock down the whole callback
   // method to prevent bad things from happening. The reason behind this is
   // that we cannot guarantee tasks on render thread have completely stopped
   // when we receive the Stop() method call. So only way to solve this is to
   // let tasks on render thread to run but make sure they don't call outside
   // this object when Stop() method is ever called. Locking this method is safe
   // because |lock_| is only acquired in tasks on render thread.
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   if (stop_signal_received_)
     return;
 
   if (error > 0) {
     // If a position error code is received, read was successful. So copy
     // from intermediate read buffer to the target read buffer.
     memcpy(read_buffer_, intermediate_read_buffer_.get(), error);
   }
   DoneRead_Locked(error);
 }
@@ skipping 15 matching lines @@
     return;
 
   // We need to prevent calling to filter host and running the callback if
   // we have received the stop signal. We need to lock down the whole callback
   // method to prevent bad things from happening. The reason behind this is
   // that we cannot guarantee tasks on render thread have completely stopped
   // when we receive the Stop() method call. So only way to solve this is to
   // let tasks on render thread to run but make sure they don't call outside
   // this object when Stop() method is ever called. Locking this method is safe
   // because |lock_| is only acquired in tasks on render thread.
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   if (stop_signal_received_)
     return;
 
   if (network_activity != network_activity_) {
     network_activity_ = network_activity;
     host()->SetNetworkActivity(network_activity);
   }
   host()->SetBufferedBytes(buffered_position + 1);
 }
 
 }  // namespace webkit_glue