Move PPB_NetAddress out of dev.

ppapi/tests/test_host_resolver.cc

 // Copyright 2013 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 "ppapi/tests/test_host_resolver.h"
 
 #include "ppapi/cpp/dev/host_resolver_dev.h"
-#include "ppapi/cpp/dev/net_address_dev.h"
 #include "ppapi/cpp/dev/tcp_socket_dev.h"
+#include "ppapi/cpp/net_address.h"
 #include "ppapi/cpp/var.h"
 #include "ppapi/tests/test_utils.h"
 #include "ppapi/tests/testing_instance.h"
 
 REGISTER_TEST_CASE(HostResolver);
 
 TestHostResolver::TestHostResolver(TestingInstance* instance)
     : TestCase(instance) {
 }
 
@@ skipping 19 matching lines @@
 }
 
 void TestHostResolver::RunTests(const std::string& filter) {
   RUN_TEST(Empty, filter);
   RUN_CALLBACK_TEST(TestHostResolver, Resolve, filter);
   RUN_CALLBACK_TEST(TestHostResolver, ResolveIPv4, filter);
 }
 
 std::string TestHostResolver::SyncConnect(
     pp::TCPSocket_Dev* socket,
-    const pp::NetAddress_Dev& address) {
+    const pp::NetAddress& address) {
   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
   callback.WaitForResult(socket->Connect(address, callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(PP_OK, callback.result());
   PASS();
 }
 
 std::string TestHostResolver::SyncRead(pp::TCPSocket_Dev* socket,
                                        char* buffer,
                                        int32_t num_bytes,
@@ skipping 52 matching lines @@
 
 std::string TestHostResolver::ParameterizedTestResolve(
     const PP_HostResolver_Hint_Dev& hint) {
   pp::HostResolver_Dev host_resolver(instance_);
 
   ASSERT_SUBTEST_SUCCESS(SyncResolve(&host_resolver, host_, port_, hint));
 
   size_t size = host_resolver.GetNetAddressCount();
   ASSERT_TRUE(size >= 1);
 
-  pp::NetAddress_Dev address;
+  pp::NetAddress address;
   for (size_t i = 0; i < size; ++i) {
     address = host_resolver.GetNetAddress(i);
     ASSERT_NE(0, address.pp_resource());
 
     pp::TCPSocket_Dev socket(instance_);
     ASSERT_SUBTEST_SUCCESS(SyncConnect(&socket, address));
     ASSERT_SUBTEST_SUCCESS(CheckHTTPResponse(&socket,
                                              "GET / HTTP/1.0\r\n\r\n",
                                              "HTTP"));
     socket.Close();
   }
 
   address = host_resolver.GetNetAddress(size);
   ASSERT_EQ(0, address.pp_resource());
   pp::Var canonical_name = host_resolver.GetCanonicalName();
   ASSERT_TRUE(canonical_name.is_string());
 
   ASSERT_SUBTEST_SUCCESS(SyncResolve(&host_resolver, canonical_name.AsString(),
                                      port_, hint));
   size = host_resolver.GetNetAddressCount();
   ASSERT_TRUE(size >= 1);
 
   PASS();
 }
 
 std::string TestHostResolver::TestEmpty() {
   pp::HostResolver_Dev host_resolver(instance_);
   ASSERT_EQ(0, host_resolver.GetNetAddressCount());
-  pp::NetAddress_Dev address = host_resolver.GetNetAddress(0);
+  pp::NetAddress address = host_resolver.GetNetAddress(0);
   ASSERT_EQ(0, address.pp_resource());
 
   PASS();
 }
 
 std::string TestHostResolver::TestResolve() {
   PP_HostResolver_Hint_Dev hint;
   hint.family = PP_NETADDRESS_FAMILY_UNSPECIFIED;
   hint.flags = PP_HOSTRESOLVER_FLAGS_CANONNAME;
   return ParameterizedTestResolve(hint);
 }
 
 std::string TestHostResolver::TestResolveIPv4() {
   PP_HostResolver_Hint_Dev hint;
   hint.family = PP_NETADDRESS_FAMILY_IPV4;
   hint.flags = PP_HOSTRESOLVER_FLAGS_CANONNAME;
   return ParameterizedTestResolve(hint);
 }