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

net/socket/ssl_client_socket_openssl.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.
 
 // OpenSSL binding for SSLClientSocket. The class layout and general principle
 // of operation is derived from SSLClientSocketNSS.
 
 #include "net/socket/ssl_client_socket_openssl.h"
 
 #include <openssl/ssl.h>
 #include <openssl/err.h>
 
-#include "base/lock.h"
 #include "base/metrics/histogram.h"
 #include "base/openssl_util.h"
 #include "base/singleton.h"
+#include "base/synchronization/lock.h"
 #include "net/base/cert_verifier.h"
 #include "net/base/net_errors.h"
 #include "net/base/openssl_private_key_store.h"
 #include "net/base/ssl_cert_request_info.h"
 #include "net/base/ssl_connection_status_flags.h"
 #include "net/base/ssl_info.h"
 #include "net/socket/ssl_error_params.h"
 
 namespace net {
 
@@ skipping 173 matching lines @@
 // side policy for that cache about session re-use: we retain one session per
 // unique HostPortPair.
 class SSLSessionCache {
  public:
   SSLSessionCache() {}
 
   void OnSessionAdded(const HostPortPair& host_and_port, SSL_SESSION* session) {
     // Declare the session cleaner-upper before the lock, so any call into
     // OpenSSL to free the session will happen after the lock is released.
     base::ScopedOpenSSL<SSL_SESSION, SSL_SESSION_free> session_to_free;
-    AutoLock lock(lock_);
+    base::AutoLock lock(lock_);
 
     DCHECK_EQ(0U, session_map_.count(session));
     std::pair<HostPortMap::iterator, bool> res =
         host_port_map_.insert(std::make_pair(host_and_port, session));
     if (!res.second) {  // Already exists: replace old entry.
       session_to_free.reset(res.first->second);
       session_map_.erase(session_to_free.get());
       res.first->second = session;
     }
     DVLOG(2) << "Adding session " << session << " => "
              << host_and_port.ToString() << ", new entry = " << res.second;
     DCHECK(host_port_map_[host_and_port] == session);
     session_map_[session] = res.first;
     DCHECK_EQ(host_port_map_.size(), session_map_.size());
     DCHECK_LE(host_port_map_.size(), kSessionCacheMaxEntires);
   }
 
   void OnSessionRemoved(SSL_SESSION* session) {
     // Declare the session cleaner-upper before the lock, so any call into
     // OpenSSL to free the session will happen after the lock is released.
     base::ScopedOpenSSL<SSL_SESSION, SSL_SESSION_free> session_to_free;
-    AutoLock lock(lock_);
+    base::AutoLock lock(lock_);
 
     SessionMap::iterator it = session_map_.find(session);
     if (it == session_map_.end())
       return;
     DVLOG(2) << "Remove session " << session << " => "
              << it->second->first.ToString();
     DCHECK(it->second->second == session);
     host_port_map_.erase(it->second);
     session_map_.erase(it);
     session_to_free.reset(session);
     DCHECK_EQ(host_port_map_.size(), session_map_.size());
   }
 
   // Looks up the host:port in the cache, and if a session is found it is added
   // to |ssl|, returning true on success.
   bool SetSSLSession(SSL* ssl, const HostPortPair& host_and_port) {
-    AutoLock lock(lock_);
+    base::AutoLock lock(lock_);
     HostPortMap::iterator it = host_port_map_.find(host_and_port);
     if (it == host_port_map_.end())
       return false;
     DVLOG(2) << "Lookup session: " << it->second << " => "
              << host_and_port.ToString();
     SSL_SESSION* session = it->second;
     DCHECK(session);
     DCHECK(session_map_[session] == it);
     // Ideally we'd release |lock_| before calling into OpenSSL here, however
     // that opens a small risk |session| will go out of scope before it is used.
     // Alternatively we would take a temporary local refcount on |session|,
     // except OpenSSL does not provide a public API for adding a ref (c.f.
     // SSL_SESSION_free which decrements the ref).
     return SSL_set_session(ssl, session) == 1;
   }
 
  private:
   // A pair of maps to allow bi-directional lookups between host:port and an
   // associated session.
   // TODO(joth): When client certificates are implemented we should key the
   // cache on the client certificate used in addition to the host-port pair.
   typedef std::map<HostPortPair, SSL_SESSION*> HostPortMap;
   typedef std::map<SSL_SESSION*, HostPortMap::iterator> SessionMap;
   HostPortMap host_port_map_;
   SessionMap session_map_;
 
   // Protects access to both the above maps.
-  Lock lock_;
+  base::Lock lock_;
 
   DISALLOW_COPY_AND_ASSIGN(SSLSessionCache);
 };
 
 class SSLContext {
  public:
   static SSLContext* GetInstance() { return Singleton<SSLContext>::get(); }
   SSL_CTX* ssl_ctx() { return ssl_ctx_.get(); }
   SSLSessionCache* session_cache() { return &session_cache_; }
 
@@ skipping 895 matching lines @@
   int rv = SSL_write(ssl_, user_write_buf_->data(), user_write_buf_len_);
 
   if (rv >= 0)
     return rv;
 
   int err = SSL_get_error(ssl_, rv);
   return MapOpenSSLError(err, err_tracer);
 }
 
 }  // namespace net