Create a QUIC wrapper around a mutex and a mutex lock.

net/tools/quic/test_tools/quic_test_server.cc

 // Copyright (c) 2015 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 "net/tools/quic/test_tools/quic_test_server.h"
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/synchronization/lock.h"
@@ skipping 84 matching lines @@
                              std::move(session_helper),
                              std::move(alarm_factory),
                              response_cache),
         session_factory_(nullptr),
         stream_factory_(nullptr),
         crypto_stream_factory_(nullptr) {}
 
   QuicServerSessionBase* CreateQuicSession(
       QuicConnectionId id,
       const QuicSocketAddress& client) override {
-    base::AutoLock lock(factory_lock_);
+    QuicReaderMutexLock lock(&factory_lock_);
     if (session_factory_ == nullptr && stream_factory_ == nullptr &&
         crypto_stream_factory_ == nullptr) {
       return QuicSimpleDispatcher::CreateQuicSession(id, client);
     }
     QuicConnection* connection = new QuicConnection(
         id, client, helper(), alarm_factory(), CreatePerConnectionWriter(),
         /* owns_writer= */ true, Perspective::IS_SERVER,
         GetSupportedVersions());
 
     QuicServerSessionBase* session = nullptr;
     if (stream_factory_ != nullptr || crypto_stream_factory_ != nullptr) {
       session = new CustomStreamSession(
           config(), connection, this, session_helper(), crypto_config(),
           compressed_certs_cache(), stream_factory_, crypto_stream_factory_,
           response_cache());
     } else {
       session = session_factory_->CreateSession(
           config(), connection, this, session_helper(), crypto_config(),
           compressed_certs_cache(), response_cache());
     }
     session->Initialize();
     return session;
   }
 
   void SetSessionFactory(QuicTestServer::SessionFactory* factory) {
-    base::AutoLock lock(factory_lock_);
+    QuicWriterMutexLock lock(&factory_lock_);
     DCHECK(session_factory_ == nullptr);
     DCHECK(stream_factory_ == nullptr);
     DCHECK(crypto_stream_factory_ == nullptr);
     session_factory_ = factory;
   }
 
   void SetStreamFactory(QuicTestServer::StreamFactory* factory) {
-    base::AutoLock lock(factory_lock_);
+    QuicWriterMutexLock lock(&factory_lock_);
     DCHECK(session_factory_ == nullptr);
     DCHECK(stream_factory_ == nullptr);
     stream_factory_ = factory;
   }
 
   void SetCryptoStreamFactory(QuicTestServer::CryptoStreamFactory* factory) {
-    base::AutoLock lock(factory_lock_);
+    QuicWriterMutexLock lock(&factory_lock_);
     DCHECK(session_factory_ == nullptr);
     DCHECK(crypto_stream_factory_ == nullptr);
     crypto_stream_factory_ = factory;
   }
 
  private:
-  base::Lock factory_lock_;
+  QuicMutex factory_lock_;
   QuicTestServer::SessionFactory* session_factory_;             // Not owned.
   QuicTestServer::StreamFactory* stream_factory_;               // Not owned.
   QuicTestServer::CryptoStreamFactory* crypto_stream_factory_;  // Not owned.
 };
 
 QuicTestServer::QuicTestServer(std::unique_ptr<ProofSource> proof_source,
                                QuicHttpResponseCache* response_cache)
     : QuicServer(std::move(proof_source), response_cache) {}
 
 QuicTestServer::QuicTestServer(std::unique_ptr<ProofSource> proof_source,
@@ skipping 50 matching lines @@
                               compressed_certs_cache,
                               response_cache) {}
 
 void ImmediateGoAwaySession::OnStreamFrame(const QuicStreamFrame& frame) {
   SendGoAway(QUIC_PEER_GOING_AWAY, "");
   QuicSimpleServerSession::OnStreamFrame(frame);
 }
 
 }  // namespace test
 }  // namespace net