Move PPB_TCPSocket 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/tcp_socket_dev.h"
 #include "ppapi/cpp/net_address.h"
+#include "ppapi/cpp/tcp_socket.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) {
 }
 
 bool TestHostResolver::Init() {
   bool host_resolver_is_available = pp::HostResolver_Dev::IsAvailable();
   if (!host_resolver_is_available)
     instance_->AppendError("PPB_HostResolver interface not available");
 
-  bool tcp_socket_is_available = pp::TCPSocket_Dev::IsAvailable();
+  bool tcp_socket_is_available = pp::TCPSocket::IsAvailable();
   if (!tcp_socket_is_available)
     instance_->AppendError("PPB_TCPSocket interface not available");
 
   bool init_host_port =
       GetLocalHostPort(instance_->pp_instance(), &host_, &port_);
   if (!init_host_port)
     instance_->AppendError("Can't init host and port");
 
   return host_resolver_is_available &&
       tcp_socket_is_available &&
       init_host_port &&
       CheckTestingInterface() &&
       EnsureRunningOverHTTP();
 }
 
 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,
+    pp::TCPSocket* socket,
     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,
+std::string TestHostResolver::SyncRead(pp::TCPSocket* socket,
                                        char* buffer,
                                        int32_t num_bytes,
                                        int32_t* bytes_read) {
   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
   callback.WaitForResult(
       socket->Read(buffer, num_bytes, callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(num_bytes, callback.result());
   *bytes_read = callback.result();
   PASS();
 }
 
-std::string TestHostResolver::SyncWrite(pp::TCPSocket_Dev* socket,
+std::string TestHostResolver::SyncWrite(pp::TCPSocket* socket,
                                         const char* buffer,
                                         int32_t num_bytes,
                                         int32_t* bytes_written) {
   TestCompletionCallback callback(instance_->pp_instance(), callback_type());
   callback.WaitForResult(
       socket->Write(buffer, num_bytes, callback.GetCallback()));
   CHECK_CALLBACK_BEHAVIOR(callback);
   ASSERT_EQ(num_bytes, callback.result());
   *bytes_written = callback.result();
   PASS();
 }
 
-std::string TestHostResolver::CheckHTTPResponse(pp::TCPSocket_Dev* socket,
+std::string TestHostResolver::CheckHTTPResponse(pp::TCPSocket* socket,
                                                 const std::string& request,
                                                 const std::string& response) {
   int32_t rv = 0;
   ASSERT_SUBTEST_SUCCESS(
       SyncWrite(socket, request.c_str(), request.size(), &rv));
   std::vector<char> response_buffer(response.size());
   ASSERT_SUBTEST_SUCCESS(
       SyncRead(socket, &response_buffer[0], response.size(), &rv));
   std::string actual_response(&response_buffer[0], rv);
   if (response != actual_response) {
@@ skipping 23 matching lines @@
   ASSERT_SUBTEST_SUCCESS(SyncResolve(&host_resolver, host_, port_, hint));
 
   size_t size = host_resolver.GetNetAddressCount();
   ASSERT_TRUE(size >= 1);
 
   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_);
+    pp::TCPSocket 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();
@@ skipping 22 matching lines @@
   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);
 }