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

webkit/glue/media/simple_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/simple_data_source.h"
 
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "media/base/filter_host.h"
 #include "net/base/data_url.h"
@@ skipping 17 matching lines @@
     : render_loop_(render_loop),
       frame_(frame),
       size_(-1),
       single_origin_(true),
       state_(UNINITIALIZED),
       keep_test_loader_(false) {
   DCHECK(render_loop);
 }
 
 SimpleDataSource::~SimpleDataSource() {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   DCHECK(state_ == UNINITIALIZED || state_ == STOPPED);
 }
 
 void SimpleDataSource::Stop(media::FilterCallback* callback) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   state_ = STOPPED;
   if (callback) {
     callback->Run();
     delete callback;
   }
 
   // Post a task to the render thread to cancel loading the resource.
   render_loop_->PostTask(FROM_HERE,
       NewRunnableMethod(this, &SimpleDataSource::CancelTask));
 }
 
 void SimpleDataSource::Initialize(const std::string& url,
                                   media::FilterCallback* callback) {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, UNINITIALIZED);
   DCHECK(callback);
   state_ = INITIALIZING;
   initialize_callback_.reset(callback);
 
   // Validate the URL.
   SetURL(GURL(url));
   if (!url_.is_valid() || !IsProtocolSupportedForMedia(url_)) {
     host()->SetError(media::PIPELINE_ERROR_NETWORK);
     initialize_callback_->Run();
@@ skipping 82 matching lines @@
     WebKit::WebURLLoader* loader,
     const char* data,
     int dataLength) {
   NOTIMPLEMENTED();
 }
 
 void SimpleDataSource::didFinishLoading(
     WebKit::WebURLLoader* loader,
     double finishTime) {
   DCHECK(MessageLoop::current() == render_loop_);
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   // It's possible this gets called after Stop(), in which case |host_| is no
   // longer valid.
   if (state_ == STOPPED)
     return;
 
   // Otherwise we should be initializing and have created a WebURLLoader.
   DCHECK_EQ(state_, INITIALIZING);
 
   // If we don't get a content length or the request has failed, report it
   // as a network error.
   if (size_ == -1)
     size_ = data_.length();
   DCHECK(static_cast<size_t>(size_) == data_.length());
 
   DoneInitialization_Locked(true);
 }
 
 void SimpleDataSource::didFail(
     WebKit::WebURLLoader* loader,
     const WebKit::WebURLError& error) {
   DCHECK(MessageLoop::current() == render_loop_);
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   // It's possible this gets called after Stop(), in which case |host_| is no
   // longer valid.
   if (state_ == STOPPED)
     return;
 
   // Otherwise we should be initializing and have created a WebURLLoader.
   DCHECK_EQ(state_, INITIALIZING);
 
   // If we don't get a content length or the request has failed, report it
   // as a network error.
@@ skipping 17 matching lines @@
 void SimpleDataSource::SetURL(const GURL& url) {
   url_ = url;
   media_format_.Clear();
   media_format_.SetAsString(media::MediaFormat::kMimeType,
                             media::mime_type::kApplicationOctetStream);
   media_format_.SetAsString(media::MediaFormat::kURL, url.spec());
 }
 
 void SimpleDataSource::StartTask() {
   DCHECK(MessageLoop::current() == render_loop_);
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
 
   // We may have stopped.
   if (state_ == STOPPED)
     return;
 
   CHECK(frame_);
 
   DCHECK_EQ(state_, INITIALIZING);
 
   if (url_.SchemeIs(kDataScheme)) {
@@ skipping 15 matching lines @@
     if (!keep_test_loader_)
       url_loader_.reset(frame_->createAssociatedURLLoader());
 
     // Start the resource loading.
     url_loader_->loadAsynchronously(request, this);
   }
 }
 
 void SimpleDataSource::CancelTask() {
   DCHECK(MessageLoop::current() == render_loop_);
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, STOPPED);
 
   // Cancel any pending requests.
   if (url_loader_.get()) {
     url_loader_->cancel();
     url_loader_.reset();
   }
 }
 
 void SimpleDataSource::DoneInitialization_Locked(bool success) {
   lock_.AssertAcquired();
   if (success) {
     state_ = INITIALIZED;
     host()->SetTotalBytes(size_);
     host()->SetBufferedBytes(size_);
     // If scheme is file or data, say we are loaded.
     host()->SetLoaded(url_.SchemeIsFile() || url_.SchemeIs(kDataScheme));
   } else {
     host()->SetError(media::PIPELINE_ERROR_NETWORK);
   }
   initialize_callback_->Run();
   initialize_callback_.reset();
 }
 
 }  // namespace webkit_glue