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

chrome/browser/policy/device_management_policy_cache.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 "chrome/browser/policy/device_management_policy_cache.h"
 
 #include <limits>
 #include <string>
 
 #include "base/file_util.h"
@@ skipping 86 matching lines @@
   if (timestamp > base::Time::NowFromSystemTime()) {
     LOG(WARNING) << "Rejected policy data from " << backing_file_path_.value()
                  << ", file is from the future.";
     return;
   }
   is_device_unmanaged_ = cached_policy.unmanaged();
 
   // Decode and swap in the new policy information.
   scoped_ptr<DictionaryValue> value(DecodePolicy(cached_policy.policy()));
   {
-    AutoLock lock(lock_);
+    base::AutoLock lock(lock_);
     if (!fresh_policy_)
       policy_.reset(value.release());
     last_policy_refresh_time_ = timestamp;
   }
 }
 
 bool DeviceManagementPolicyCache::SetPolicy(
     const em::DevicePolicyResponse& policy) {
   is_device_unmanaged_ = false;
   DictionaryValue* value = DeviceManagementPolicyCache::DecodePolicy(policy);
   const bool new_policy_differs = !(value->Equals(policy_.get()));
   base::Time now(base::Time::NowFromSystemTime());
   {
-    AutoLock lock(lock_);
+    base::AutoLock lock(lock_);
     policy_.reset(value);
     fresh_policy_ = true;
     last_policy_refresh_time_ = now;
   }
 
   em::DevicePolicyResponse* policy_copy = new em::DevicePolicyResponse;
   policy_copy->CopyFrom(policy);
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
       new PersistPolicyTask(backing_file_path_, policy_copy, now, false));
   return new_policy_differs;
 }
 
 DictionaryValue* DeviceManagementPolicyCache::GetPolicy() {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   return static_cast<DictionaryValue*>(policy_->DeepCopy());
 }
 
 void DeviceManagementPolicyCache::SetDeviceUnmanaged(bool is_device_unmanaged) {
   if (is_device_unmanaged_ == is_device_unmanaged)
     return;
 
   is_device_unmanaged_ = is_device_unmanaged;
   base::Time now(base::Time::NowFromSystemTime());
   DictionaryValue* empty = new DictionaryValue();
   {
-    AutoLock lock(lock_);
+    base::AutoLock lock(lock_);
     policy_.reset(empty);
     last_policy_refresh_time_ = now;
   }
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
       new PersistPolicyTask(backing_file_path_,
                             (is_device_unmanaged ? NULL
                                 : new em::DevicePolicyResponse()),
                             now,
@@ skipping 109 matching lines @@
             DeviceManagementPolicyCache::DecodeValue(named_value->value());
         if (decoded_value)
           result->Set(named_value->name(), decoded_value);
       }
     }
   }
   return result;
 }
 
 }  // namespace policy