cronet: Fix StaleHostResolver.AddressListDelta histogram.

components/cronet/stale_host_resolver.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/cronet/stale_host_resolver.h"
 
 #include "base/callback_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
@@ skipping 121 matching lines @@
   bool have_handle() const { return handle_ != nullptr; }
 
   // Callback for |stale_timer_| that returns stale results.
   void OnStaleDelayElapsed();
   // Callback for network request that returns fresh results if the request
   // hasn't already returned stale results, and completes the request.
   void OnNetworkRequestComplete(int error);
   void OnHandleDestroyed();
 
   // Fills |*result_addresses_| if rv is OK and returns rv.
-  int HandleResult(int rv, net::AddressList* addresses);
+  int HandleResult(int rv, const net::AddressList& addresses);
   // Fills |*result_addresses_| if rv is OK and calls |result_callback_| with
   // rv.
-  void ReturnResult(int rv, net::AddressList* addresses);
+  void ReturnResult(int rv, const net::AddressList& addresses);
 
   void MaybeDeleteThis();
 
   void RecordSynchronousRequest();
   void RecordNetworkRequest(int error, bool returned_stale_data);
   void RecordCanceledRequest();
 
   // The address list passed into |Start()| to be filled in when the request
   // returns.
   net::AddressList* result_addresses_;
@@ skipping 50 matching lines @@
 
   result_addresses_ = addresses;
 
   net::AddressList cache_addresses;
   net::HostCache::EntryStaleness stale_info;
   int cache_rv = resolver->ResolveStaleFromCache(info, &cache_addresses,
                                                  &stale_info, net_log);
   // If it's a fresh cache hit (or literal), return it synchronously.
   if (cache_rv != net::ERR_DNS_CACHE_MISS && !stale_info.is_stale()) {
     RecordSynchronousRequest();
-    return HandleResult(cache_rv, &cache_addresses);
+    return HandleResult(cache_rv, cache_addresses);
   }
 
   result_callback_ = result_callback;
   handle_ = new Handle(this);
   *out_req = std::unique_ptr<net::HostResolver::Request>(handle_);
 
   if (cache_rv != net::ERR_DNS_CACHE_MISS && usable_callback.Run(stale_info)) {
     stale_error_ = cache_rv;
     stale_addresses_ = cache_addresses;
     // |stale_timer_| is deleted when the Request is deleted, so it's safe to
@@ skipping 20 matching lines @@
     net::RequestPriority priority) {
   DCHECK(have_network_request());
 
   network_request_->ChangeRequestPriority(priority);
 }
 
 void StaleHostResolver::RequestImpl::OnStaleDelayElapsed() {
   DCHECK(!have_returned());
   DCHECK(have_stale_data());
 
-  ReturnResult(stale_error_, &stale_addresses_);
+  ReturnResult(stale_error_, stale_addresses_);
 
   // The request needs to wait for both the network request to complete (to
   // backfill the cache) and the caller to delete the handle before deleting
   // itself.
   DCHECK(have_network_request());
 }
 
 void StaleHostResolver::RequestImpl::OnNetworkRequestComplete(int error) {
   DCHECK(have_network_request());
   network_request_.reset();
 
   RecordNetworkRequest(error, /* returned_stale_data = */ have_returned());
 
   if (!have_returned()) {
     if (have_stale_data())
       stale_timer_.Stop();
-    ReturnResult(error, &network_addresses_);
+    ReturnResult(error, network_addresses_);
   }
 
   if (!have_handle())
     delete this;
 }
 
 void StaleHostResolver::RequestImpl::OnHandleDestroyed() {
   DCHECK(have_handle());
   handle_ = nullptr;
 
   // If the caller deletes the handle *before* the request has returned, treat
   // it as a cancel.
   if (!have_returned()) {
     network_request_.reset();
     result_callback_ = net::CompletionCallback();
     RecordCanceledRequest();
   }
 
   if (!returning_result_ && !have_handle() && !have_network_request())
     delete this;
 }
 
-int StaleHostResolver::RequestImpl::HandleResult(int rv,
-                                                 net::AddressList* addresses) {
+int StaleHostResolver::RequestImpl::HandleResult(
+    int rv,
+    const net::AddressList& addresses) {
   DCHECK(result_addresses_);
 
-  if (rv == net::OK) {
-    *result_addresses_ = *addresses;
-    addresses->clear();
-  }
+  if (rv == net::OK)
+    *result_addresses_ = addresses;
   result_addresses_ = nullptr;
   return rv;
 }
 
-void StaleHostResolver::RequestImpl::ReturnResult(int rv,
-                                                  net::AddressList* addresses) {
+void StaleHostResolver::RequestImpl::ReturnResult(
+    int rv,
+    const net::AddressList& addresses) {
   DCHECK(result_callback_);
   returning_result_ = true;
   base::ResetAndReturn(&result_callback_).Run(HandleResult(rv, addresses));
   returning_result_ = false;
 }
 
 void StaleHostResolver::RequestImpl::RecordSynchronousRequest() {
   RecordRequestOutcome(SYNCHRONOUS);
 }
 
@@ skipping 70 matching lines @@
 
 net::HostCache* StaleHostResolver::GetHostCache() {
   return inner_resolver_->GetHostCache();
 }
 
 std::unique_ptr<base::Value> StaleHostResolver::GetDnsConfigAsValue() const {
   return inner_resolver_->GetDnsConfigAsValue();
 }
 
 }  // namespace net