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

chrome/common/local_discovery/service_discovery_client_unittest.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 "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/common/local_discovery/service_discovery_client_impl.h"
@@ skipping 392 matching lines @@
 
   base::MessageLoop::current()->RunUntilIdle();
 };
 
 
 class ServiceResolverTest : public ServiceDiscoveryTest {
  public:
   ServiceResolverTest() {
     metadata_expected_.push_back("hello");
     address_expected_ = net::HostPortPair("myhello.local", 8888);
-    ip_address_expected_.push_back(1);
-    ip_address_expected_.push_back(2);
-    ip_address_expected_.push_back(3);
-    ip_address_expected_.push_back(4);
+    uint8_t address[4] = {1, 2, 3, 4};
+    ip_address_expected_ = net::IPAddress(address, sizeof(address));

[eroman, 2015/12/21 20:47:33]

This pattern is common enough, that you might want o create a constructor that
takes an array (and infers the length using template)

[martijnc, 2016/01/27 22:50:52]

Replaced with IPAddress::FromIPLiteral().

   }
 
   ~ServiceResolverTest() {
   }
 
   void SetUp()  {
     resolver_ = service_discovery_client_.CreateServiceResolver(
                     "hello._privet._tcp.local",
                      base::Bind(&ServiceResolverTest::OnFinishedResolving,
                                 base::Unretained(this)));
   }
 
   void OnFinishedResolving(ServiceResolver::RequestStatus request_status,
                            const ServiceDescription& service_description) {
     OnFinishedResolvingInternal(request_status,
                                 service_description.address.ToString(),
                                 service_description.metadata,
                                 service_description.ip_address);
   }
 
   MOCK_METHOD4(OnFinishedResolvingInternal,
                void(ServiceResolver::RequestStatus,
                     const std::string&,
                     const std::vector<std::string>&,
-                    const net::IPAddressNumber&));
+                    const net::IPAddress&));
 
  protected:
   scoped_ptr<ServiceResolver> resolver_;
-  net::IPAddressNumber ip_address_;
+  net::IPAddress ip_address_;
   net::HostPortPair address_expected_;
   std::vector<std::string> metadata_expected_;
-  net::IPAddressNumber ip_address_expected_;
+  net::IPAddress ip_address_expected_;
 };
 
 TEST_F(ServiceResolverTest, TxtAndSrvButNoA) {
   EXPECT_CALL(socket_factory_, OnSendTo(_)).Times(4);
 
   resolver_->StartResolving();
 
   socket_factory_.SimulateReceive(kSamplePacketSRV, sizeof(kSamplePacketSRV));
 
   base::MessageLoop::current()->RunUntilIdle();
 
-  EXPECT_CALL(*this,
-              OnFinishedResolvingInternal(ServiceResolver::STATUS_SUCCESS,
-                                          address_expected_.ToString(),
-                                          metadata_expected_,
-                                          net::IPAddressNumber()));
+  EXPECT_CALL(
+      *this, OnFinishedResolvingInternal(ServiceResolver::STATUS_SUCCESS,
+                                         address_expected_.ToString(),
+                                         metadata_expected_, net::IPAddress()));
 
   socket_factory_.SimulateReceive(kSamplePacketTXT, sizeof(kSamplePacketTXT));
 };
 
 TEST_F(ServiceResolverTest, TxtSrvAndA) {
   EXPECT_CALL(socket_factory_, OnSendTo(_)).Times(4);
 
   resolver_->StartResolving();
 
   EXPECT_CALL(*this,
@@ skipping 34 matching lines @@
                          ServiceResolver::STATUS_REQUEST_TIMEOUT, _, _, _));
 
   // TODO(noamsml): When NSEC record support is added, change this to use an
   // NSEC record.
   RunFor(base::TimeDelta::FromSeconds(4));
 };
 
 }  // namespace
 
 }  // namespace local_discovery