Revert of Migrate Local Discovery from net::IPAddressNumber to net::IPAddress.

chrome/browser/local_discovery/service_discovery_client_impl.cc

 // Copyright 2014 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 <utility>
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 417 matching lines @@
 }
 
 void ServiceResolverImpl::ARecordTransactionResponse(
     net::MDnsTransaction::Result status, const net::RecordParsed* record) {
   a_transaction_.reset();
 
   if (status == net::MDnsTransaction::RESULT_RECORD) {
     DCHECK(record);
     service_staging_.ip_address = RecordToIPAddress(record);
   } else {
-    service_staging_.ip_address = net::IPAddress();
+    service_staging_.ip_address = net::IPAddressNumber();
   }
 
   address_resolved_ = true;
   AlertCallbackIfReady();
 }
 
 void ServiceResolverImpl::AlertCallbackIfReady() {
   if (metadata_resolved_ && address_resolved_) {
     txt_transaction_.reset();
     srv_transaction_.reset();
@@ skipping 37 matching lines @@
 }
 
 net::HostPortPair ServiceResolverImpl::RecordToAddress(
     const net::RecordParsed* record) const {
   DCHECK(record->type() == net::dns_protocol::kTypeSRV);
   const net::SrvRecordRdata* srv_rdata = record->rdata<net::SrvRecordRdata>();
   DCHECK(srv_rdata);
   return net::HostPortPair(srv_rdata->target(), srv_rdata->port());
 }
 
-net::IPAddress ServiceResolverImpl::RecordToIPAddress(
+const net::IPAddressNumber& ServiceResolverImpl::RecordToIPAddress(
     const net::RecordParsed* record) const {
   DCHECK(record->type() == net::dns_protocol::kTypeA);
   const net::ARecordRdata* a_rdata = record->rdata<net::ARecordRdata>();
   DCHECK(a_rdata);
-  return net::IPAddress(a_rdata->address());
+  return a_rdata->address();
 }
 
 LocalDomainResolverImpl::LocalDomainResolverImpl(
     const std::string& domain,
     net::AddressFamily address_family,
     const IPAddressCallback& callback,
     net::MDnsClient* mdns_client)
     : domain_(domain), address_family_(address_family), callback_(callback),
       transactions_finished_(0), mdns_client_(mdns_client) {
 }
@@ skipping 26 matching lines @@
                  base::Unretained(this)));
 }
 
 void LocalDomainResolverImpl::OnTransactionComplete(
     net::MDnsTransaction::Result result, const net::RecordParsed* record) {
   transactions_finished_++;
 
   if (result == net::MDnsTransaction::RESULT_RECORD) {
     if (record->type() == net::dns_protocol::kTypeA) {
       const net::ARecordRdata* rdata = record->rdata<net::ARecordRdata>();
-      address_ipv4_ = net::IPAddress(rdata->address());
+      address_ipv4_ = rdata->address();
     } else {
       DCHECK_EQ(net::dns_protocol::kTypeAAAA, record->type());
       const net::AAAARecordRdata* rdata = record->rdata<net::AAAARecordRdata>();
-      address_ipv6_ = net::IPAddress(rdata->address());
+      address_ipv6_ = rdata->address();
     }
   }
 
   if (transactions_finished_ == 1 &&
       address_family_ == net::ADDRESS_FAMILY_UNSPECIFIED) {
     timeout_callback_.Reset(base::Bind(
         &LocalDomainResolverImpl::SendResolvedAddresses,
         base::Unretained(this)));
 
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, timeout_callback_.callback(),
         base::TimeDelta::FromMilliseconds(kLocalDomainSecondAddressTimeoutMs));
   } else if (transactions_finished_ == 2
       || address_family_ != net::ADDRESS_FAMILY_UNSPECIFIED) {
     SendResolvedAddresses();
   }
 }
 
 bool LocalDomainResolverImpl::IsSuccess() {
-  return address_ipv4_.IsValid() || address_ipv6_.IsValid();
+  return !address_ipv4_.empty() || !address_ipv6_.empty();
 }
 
 void LocalDomainResolverImpl::SendResolvedAddresses() {
   transaction_a_.reset();
   transaction_aaaa_.reset();
   timeout_callback_.Cancel();
   callback_.Run(IsSuccess(), address_ipv4_, address_ipv6_);
 }
 
 }  // namespace local_discovery