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

net/quic/core/crypto/crypto_secret_boxer.cc

 // Copyright (c) 2013 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/quic/core/crypto/crypto_secret_boxer.h"
 
 #include <memory>
 
 #include "base/logging.h"
 #include "net/quic/core/crypto/aes_128_gcm_12_decrypter.h"
@@ skipping 32 matching lines @@
 size_t CryptoSecretBoxer::GetKeySize() {
   return kKeySize;
 }
 
 void CryptoSecretBoxer::SetKeys(const std::vector<string>& keys) {
   DCHECK(!keys.empty());
   std::vector<string> copy = keys;
   for (const string& key : keys) {
     DCHECK_EQ(kKeySize, key.size());
   }
-  base::AutoLock l(lock_);
+  QuicWriterMutexLock l(&lock_);
   keys_.swap(copy);
 }
 
 string CryptoSecretBoxer::Box(QuicRandom* rand, StringPiece plaintext) const {
   std::unique_ptr<Aes128Gcm12Encrypter> encrypter(new Aes128Gcm12Encrypter());
   {
-    base::AutoLock l(lock_);
+    QuicReaderMutexLock l(&lock_);
     DCHECK_EQ(kKeySize, keys_[0].size());
     if (!encrypter->SetKey(keys_[0])) {
       DLOG(DFATAL) << "CryptoSecretBoxer's encrypter->SetKey failed.";
       return string();
     }
   }
   size_t ciphertext_size = encrypter->GetCiphertextSize(plaintext.length());
 
   string ret;
   const size_t len = kBoxNonceSize + ciphertext_size;
@@ skipping 26 matching lines @@
   QuicPacketNumber packet_number;
   StringPiece nonce_prefix(nonce.data(), nonce.size() - sizeof(packet_number));
   memcpy(&packet_number, nonce.data() + nonce_prefix.size(),
          sizeof(packet_number));
 
   std::unique_ptr<Aes128Gcm12Decrypter> decrypter(new Aes128Gcm12Decrypter());
   char plaintext[kMaxPacketSize];
   size_t plaintext_length = 0;
   bool ok = false;
   {
-    base::AutoLock l(lock_);
+    QuicReaderMutexLock l(&lock_);
     for (const string& key : keys_) {
       if (decrypter->SetKey(key)) {
         decrypter->SetNoncePrefix(nonce_prefix);
         if (decrypter->DecryptPacket(
                 /*path_id=*/0u, packet_number,
                 /*associated data=*/StringPiece(), ciphertext, plaintext,
                 &plaintext_length, kMaxPacketSize)) {
           ok = true;
           break;
         }
       }
     }
   }
   if (!ok) {
     return false;
   }
 
   out_storage->resize(plaintext_length);
   out_storage->assign(plaintext, plaintext_length);
   out->set(out_storage->data(), plaintext_length);
   return true;
 }
 
 }  // namespace net