Remove a use of stl_util in safe browsing.

components/safe_browsing_db/v4_get_hash_protocol_manager.cc

 // Copyright 2016 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 "components/safe_browsing_db/v4_get_hash_protocol_manager.h"
 
 #include <utility>
 
 #include "base/base64url.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/timer/timer.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using base::Time;
 using base::TimeDelta;
@@ skipping 62 matching lines @@
       const V4ProtocolConfig& config) override {
     return new V4GetHashProtocolManager(request_context_getter, config);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(V4GetHashProtocolManagerFactoryImpl);
 };
 
 // V4GetHashProtocolManager implementation --------------------------------
 
+struct V4GetHashProtocolManager::FetcherAndCallback {
+  FetcherAndCallback(std::unique_ptr<net::URLFetcher> fetcher,
+                     FullHashCallback callback)

[mattm, 2016/08/27 01:43:25]

const ref

[Avi (use Gerrit), 2016/08/29 18:04:23]

moot

+      : fetcher(std::move(fetcher)), callback(callback) {}
+
+  std::unique_ptr<net::URLFetcher> fetcher;
+  FullHashCallback callback;
+};
+
 // static
 V4GetHashProtocolManagerFactory* V4GetHashProtocolManager::factory_ = NULL;
 
 // static
 V4GetHashProtocolManager* V4GetHashProtocolManager::Create(
     net::URLRequestContextGetter* request_context_getter,
     const V4ProtocolConfig& config) {
   if (!factory_)
     factory_ = new V4GetHashProtocolManagerFactoryImpl();
   return factory_->CreateProtocolManager(request_context_getter, config);
 }
 
 void V4GetHashProtocolManager::ResetGetHashErrors() {
   gethash_error_count_ = 0;
   gethash_back_off_mult_ = 1;
 }
 
 V4GetHashProtocolManager::V4GetHashProtocolManager(
     net::URLRequestContextGetter* request_context_getter,
     const V4ProtocolConfig& config)
     : gethash_error_count_(0),
       gethash_back_off_mult_(1),
       next_gethash_time_(Time::FromDoubleT(0)),
       config_(config),
       request_context_getter_(request_context_getter),
       url_fetcher_id_(0),
       clock_(new base::DefaultClock()) {}
 
 V4GetHashProtocolManager::~V4GetHashProtocolManager() {
-  // Delete in-progress SafeBrowsing requests.
-  STLDeleteContainerPairFirstPointers(hash_requests_.begin(),
-                                      hash_requests_.end());
-  hash_requests_.clear();
 }
 
 // static
 void V4GetHashProtocolManager::RegisterFactory(
     std::unique_ptr<V4GetHashProtocolManagerFactory> factory) {
   if (factory_)
     delete factory_;
   factory_ = factory.release();
 }
 
@@ skipping 185 matching lines @@
   std::string req_base64 = GetHashRequest(prefixes, platforms, threat_type);
   GURL gethash_url;
   net::HttpRequestHeaders headers;
   GetHashUrlAndHeaders(req_base64, &gethash_url, &headers);
 
   net::URLFetcher* fetcher =
       net::URLFetcher::Create(url_fetcher_id_++, gethash_url,
                               net::URLFetcher::GET, this)
           .release();
   fetcher->SetExtraRequestHeaders(headers.ToString());
-  hash_requests_[fetcher] = callback;
+  hash_requests_[fetcher] =
+      base::MakeUnique<FetcherAndCallback>(base::WrapUnique(fetcher), callback);
 
   fetcher->SetLoadFlags(net::LOAD_DISABLE_CACHE);
   fetcher->SetRequestContext(request_context_getter_.get());
   fetcher->Start();
 }
 
 void V4GetHashProtocolManager::GetFullHashesWithApis(
     const std::vector<SBPrefix>& prefixes,
     FullHashCallback callback) {
   std::vector<PlatformType> platform = {CHROME_PLATFORM};
   GetFullHashes(prefixes, platform, API_ABUSE, callback);
 }
 
 void V4GetHashProtocolManager::SetClockForTests(
     std::unique_ptr<base::Clock> clock) {
   clock_ = std::move(clock);
 }
 
 // net::URLFetcherDelegate implementation ----------------------------------
 
 // SafeBrowsing request responses are handled here.
 void V4GetHashProtocolManager::OnURLFetchComplete(
     const net::URLFetcher* source) {
   DCHECK(CalledOnValidThread());
 
   HashRequests::iterator it = hash_requests_.find(source);
   DCHECK(it != hash_requests_.end()) << "Request not found";
 
-  // FindFullHashes response.
-  // Reset the scoped pointer so the fetcher gets destroyed properly.
-  std::unique_ptr<const net::URLFetcher> fetcher(it->first);
-
   int response_code = source->GetResponseCode();
   net::URLRequestStatus status = source->GetStatus();
   V4ProtocolManagerUtil::RecordHttpResponseOrErrorCode(
       kUmaV4HashResponseMetricName, status, response_code);
 
-  const FullHashCallback& callback = it->second;
+  const FullHashCallback& callback = it->second->callback;
   std::vector<SBFullHashResult> full_hashes;
   base::Time negative_cache_expire;
   if (status.is_success() && response_code == net::HTTP_OK) {
     RecordGetHashResult(V4OperationResult::STATUS_200);
     ResetGetHashErrors();
     std::string data;
     source->GetResponseAsString(&data);
     if (!ParseHashResponse(data, &full_hashes, &negative_cache_expire)) {
       full_hashes.clear();
       RecordGetHashResult(V4OperationResult::PARSE_ERROR);
@@ skipping 29 matching lines @@
 
 void V4GetHashProtocolManager::GetHashUrlAndHeaders(
     const std::string& req_base64,
     GURL* gurl,
     net::HttpRequestHeaders* headers) const {
   V4ProtocolManagerUtil::GetRequestUrlAndHeaders(req_base64, "fullHashes:find",
                                                  config_, gurl, headers);
 }
 
 }  // namespace safe_browsing