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

net/tools/quic/quic_http_response_cache.cc

 // Copyright (c) 2012 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/quic_http_response_cache.h"
 
 #include <utility>
 
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
@@ skipping 145 matching lines @@
 void QuicHttpResponseCache::ResourceFile::HandleXOriginalUrl() {
   StringPiece url(x_original_url_);
   // Remove the protocol so we can add it below.
   url = RemoveScheme(url);
   SetHostPathFromBase(url);
 }
 
 const QuicHttpResponseCache::Response* QuicHttpResponseCache::GetResponse(
     StringPiece host,
     StringPiece path) const {
-  base::AutoLock lock(response_mutex_);
+  QuicWriterMutexLock lock(&response_mutex_);
 
   auto it = responses_.find(GetKey(host, path));
   if (it == responses_.end()) {
     DVLOG(1) << "Get response for resource failed: host " << host << " path "
              << path;
     if (default_response_.get()) {
       return default_response_.get();
     }
     return nullptr;
   }
@@ skipping 17 matching lines @@
     StringPiece host,
     StringPiece path,
     int response_code,
     StringPiece body,
     std::list<ServerPushInfo> push_resources) {
   AddSimpleResponse(host, path, response_code, body);
   MaybeAddServerPushResources(host, path, push_resources);
 }
 
 void QuicHttpResponseCache::AddDefaultResponse(Response* response) {
-  base::AutoLock lock(response_mutex_);
+  QuicWriterMutexLock lock(&response_mutex_);
   default_response_.reset(response);
 }
 
 void QuicHttpResponseCache::AddResponse(StringPiece host,
                                         StringPiece path,
                                         SpdyHeaderBlock response_headers,
                                         StringPiece response_body) {
   AddResponseImpl(host, path, REGULAR_RESPONSE, std::move(response_headers),
                   response_body, SpdyHeaderBlock());
 }
@@ skipping 66 matching lines @@
                                               net::kV3LowestPriority,
                                               response->body().as_string()));
     }
     MaybeAddServerPushResources(resource_file->host(), resource_file->path(),
                                 push_resources);
   }
 }
 
 std::list<ServerPushInfo> QuicHttpResponseCache::GetServerPushResources(
     string request_url) {
-  base::AutoLock lock(response_mutex_);
+  QuicWriterMutexLock lock(&response_mutex_);
 
   std::list<ServerPushInfo> resources;
   auto resource_range = server_push_resources_.equal_range(request_url);
   for (auto it = resource_range.first; it != resource_range.second; ++it) {
     resources.push_back(it->second);
   }
   DVLOG(1) << "Found " << resources.size() << " push resources for "
            << request_url;
   return resources;
 }
 
 QuicHttpResponseCache::~QuicHttpResponseCache() {
   {
-    base::AutoLock lock(response_mutex_);
+    QuicWriterMutexLock lock(&response_mutex_);
     responses_.clear();
   }
 }
 
 void QuicHttpResponseCache::AddResponseImpl(StringPiece host,
                                             StringPiece path,
                                             SpecialResponseType response_type,
                                             SpdyHeaderBlock response_headers,
                                             StringPiece response_body,
                                             SpdyHeaderBlock response_trailers) {
-  base::AutoLock lock(response_mutex_);
+  QuicWriterMutexLock lock(&response_mutex_);
 
   DCHECK(!host.empty()) << "Host must be populated, e.g. \"www.google.com\"";
   string key = GetKey(host, path);
   if (base::ContainsKey(responses_, key)) {
     QUIC_BUG << "Response for '" << key << "' already exists!";
     return;
   }
   std::unique_ptr<Response> new_response = base::MakeUnique<Response>();
   new_response->set_response_type(response_type);
   new_response->set_headers(std::move(response_headers));
@@ skipping 15 matching lines @@
 
   for (const auto& push_resource : push_resources) {
     if (PushResourceExistsInCache(request_url, push_resource)) {
       continue;
     }
 
     DVLOG(1) << "Add request-resource association: request url " << request_url
              << " push url " << push_resource.request_url
              << " response headers " << push_resource.headers.DebugString();
     {
-      base::AutoLock lock(response_mutex_);
+      QuicWriterMutexLock lock(&response_mutex_);
       server_push_resources_.insert(std::make_pair(request_url, push_resource));
     }
     string host = push_resource.request_url.host();
     if (host.empty()) {
       host = request_host.as_string();
     }
     string path = push_resource.request_url.path();
     bool found_existing_response = false;
     {
-      base::AutoLock lock(response_mutex_);
+      QuicWriterMutexLock lock(&response_mutex_);
       found_existing_response =
           base::ContainsKey(responses_, GetKey(host, path));
     }
     if (!found_existing_response) {
       // Add a server push response to responses map, if it is not in the map.
       StringPiece body = push_resource.body;
       DVLOG(1) << "Add response for push resource: host " << host << " path "
                << path;
       AddResponse(host, path, push_resource.headers.Clone(), body);
     }
   }
 }
 
 bool QuicHttpResponseCache::PushResourceExistsInCache(
     string original_request_url,
     ServerPushInfo resource) {
-  base::AutoLock lock(response_mutex_);
+  QuicWriterMutexLock lock(&response_mutex_);
   auto resource_range =
       server_push_resources_.equal_range(original_request_url);
   for (auto it = resource_range.first; it != resource_range.second; ++it) {
     ServerPushInfo push_resource = it->second;
     if (push_resource.request_url.spec() == resource.request_url.spec()) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace net