Remove stl_util's deletion functions from remaining quic code.

net/tools/quic/quic_in_memory_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_in_memory_cache.h"
 
 #include <utility>
 
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
+#include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/quic/core/quic_bug_tracker.h"
 #include "net/spdy/spdy_http_utils.h"
 
 using base::FilePath;
@@ skipping 117 matching lines @@
 // static
 QuicInMemoryCache* QuicInMemoryCache::GetInstance() {
   return base::Singleton<QuicInMemoryCache>::get();
 }
 
 const QuicInMemoryCache::Response* QuicInMemoryCache::GetResponse(
     StringPiece host,
     StringPiece path) const {
   base::AutoLock lock(response_mutex_);
 
-  ResponseMap::const_iterator it = responses_.find(GetKey(host, path));
+  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;
   }
-  return it->second;
+  return it->second.get();
 }
 
 typedef QuicInMemoryCache::ServerPushInfo ServerPushInfo;
 
 void QuicInMemoryCache::AddSimpleResponse(StringPiece host,
                                           StringPiece path,
                                           int response_code,
                                           StringPiece body) {
   SpdyHeaderBlock response_headers;
   response_headers[":status"] = IntToString(response_code);
@@ skipping 38 matching lines @@
                                            StringPiece path,
                                            SpecialResponseType response_type) {
   AddResponseImpl(host, path, response_type, SpdyHeaderBlock(), "",
                   SpdyHeaderBlock());
 }
 
 QuicInMemoryCache::QuicInMemoryCache() {}
 
 void QuicInMemoryCache::ResetForTests() {
   base::AutoLock lock(response_mutex_);
-  base::STLDeleteValues(&responses_);
+  responses_.clear();
   server_push_resources_.clear();
 }
 
 void QuicInMemoryCache::InitializeFromDirectory(const string& cache_directory) {
   if (cache_directory.empty()) {
     QUIC_BUG << "cache_directory must not be empty.";
     return;
   }
   VLOG(1) << "Attempting to initialize QuicInMemoryCache from directory: "
           << cache_directory;
@@ skipping 54 matching lines @@
     resources.push_back(it->second);
   }
   DVLOG(1) << "Found " << resources.size() << " push resources for "
            << request_url;
   return resources;
 }
 
 QuicInMemoryCache::~QuicInMemoryCache() {
   {
     base::AutoLock lock(response_mutex_);
-    base::STLDeleteValues(&responses_);
+    responses_.clear();
   }
 }
 
 void QuicInMemoryCache::AddResponseImpl(StringPiece host,
                                         StringPiece path,
                                         SpecialResponseType response_type,
                                         SpdyHeaderBlock response_headers,
                                         StringPiece response_body,
                                         SpdyHeaderBlock response_trailers) {
   base::AutoLock 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;
   }
-  Response* new_response = new Response();
+  std::unique_ptr<Response> new_response = base::MakeUnique<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));
   DVLOG(1) << "Add response with key " << key;
-  responses_[key] = new_response;
+  responses_[key] = std::move(new_response);
 }
 
 string QuicInMemoryCache::GetKey(StringPiece host, StringPiece path) const {
   return host.as_string() + path.as_string();
 }
 
 void QuicInMemoryCache::MaybeAddServerPushResources(
     StringPiece request_host,
     StringPiece request_path,
     list<ServerPushInfo> push_resources) {
@@ skipping 40 matching lines @@
   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