Add quic_map_util.

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"
-#include "base/stl_util.h"
 #include "net/http/http_util.h"
 #include "net/quic/platform/api/quic_bug_tracker.h"
 #include "net/quic/platform/api/quic_logging.h"
+#include "net/quic/platform/api/quic_map_util.h"
 #include "net/quic/platform/api/quic_ptr_util.h"
 #include "net/quic/platform/api/quic_text_utils.h"
 #include "net/spdy/spdy_http_utils.h"
 
 using base::FilePath;
 using base::IntToString;
 using base::StringPiece;
 using std::string;
 
 namespace net {
@@ skipping 284 matching lines @@
 void QuicHttpResponseCache::AddResponseImpl(StringPiece host,
                                             StringPiece path,
                                             SpecialResponseType response_type,
                                             SpdyHeaderBlock response_headers,
                                             StringPiece response_body,
                                             SpdyHeaderBlock response_trailers) {
   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)) {
+  if (QuicContainsKey(responses_, key)) {
     QUIC_BUG << "Response for '" << key << "' already exists!";
     return;
   }
   std::unique_ptr<Response> new_response = QuicMakeUnique<Response>();
   new_response->set_response_type(response_type);
   new_response->set_headers(std::move(response_headers));
   new_response->set_body(response_body);
   new_response->set_trailers(std::move(response_trailers));
   QUIC_DVLOG(1) << "Add response with key " << key;
   responses_[key] = std::move(new_response);
@@ skipping 23 matching lines @@
       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;
     {
       QuicWriterMutexLock lock(&response_mutex_);
-      found_existing_response =
-          base::ContainsKey(responses_, GetKey(host, path));
+      found_existing_response = QuicContainsKey(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;
       QUIC_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) {
   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