Return errors from the Mojo network service using an enum.

mojo/services/network/udp_socket_apptest.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/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/cpp/application/application_test_base.h"
 #include "mojo/public/cpp/bindings/callback.h"
 #include "mojo/services/network/public/cpp/udp_socket_wrapper.h"
 #include "mojo/services/network/public/interfaces/network_service.mojom.h"
 #include "mojo/services/network/public/interfaces/udp_socket.mojom.h"
-#include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace service {
 namespace {
 
 NetAddressPtr GetLocalHostWithAnyPort() {
   NetAddressPtr addr(NetAddress::New());
   addr->family = NET_ADDRESS_FAMILY_IPV4;
   addr->ipv4 = NetAddressIPv4::New();
@@ skipping 311 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(UDPSocketAppTest);
 };
 
 }  // namespace
 
 TEST_F(UDPSocketAppTest, Settings) {
   TestCallback callback1;
   socket_->AllowAddressReuse(callback1.callback());
   callback1.WaitForResult();
-  EXPECT_EQ(net::OK, callback1.result()->code);
+  EXPECT_EQ(NETWORK_CODE_OK, callback1.result()->code);
 
   // Should fail because the socket hasn't been bound.
   TestCallback callback2;
   socket_->SetSendBufferSize(1024, callback2.callback());
   callback2.WaitForResult();
-  EXPECT_NE(net::OK, callback2.result()->code);
+  EXPECT_NE(NETWORK_CODE_OK, callback2.result()->code);
 
   // Should fail because the socket hasn't been bound.
   TestCallback callback3;
   socket_->SetReceiveBufferSize(2048, callback3.callback());
   callback3.WaitForResult();
-  EXPECT_NE(net::OK, callback3.result()->code);
+  EXPECT_NE(NETWORK_CODE_OK, callback3.result()->code);
 
   TestCallbackWithAddressAndReceiver callback4;
   socket_->Bind(GetLocalHostWithAnyPort(), callback4.callback());
   callback4.WaitForResult();
-  EXPECT_EQ(net::OK, callback4.result()->code);
+  EXPECT_EQ(NETWORK_CODE_OK, callback4.result()->code);
   EXPECT_NE(0u, callback4.net_address()->ipv4->port);
 
   // Should fail because the socket has been bound.
   TestCallback callback5;
   socket_->AllowAddressReuse(callback5.callback());
   callback5.WaitForResult();
-  EXPECT_NE(net::OK, callback5.result()->code);
+  EXPECT_NE(NETWORK_CODE_OK, callback5.result()->code);
 
   TestCallback callback6;
   socket_->SetSendBufferSize(1024, callback6.callback());
   callback6.WaitForResult();
-  EXPECT_EQ(net::OK, callback6.result()->code);
+  EXPECT_EQ(NETWORK_CODE_OK, callback6.result()->code);
 
   TestCallback callback7;
   socket_->SetReceiveBufferSize(2048, callback7.callback());
   callback7.WaitForResult();
-  EXPECT_EQ(net::OK, callback7.result()->code);
+  EXPECT_EQ(NETWORK_CODE_OK, callback7.result()->code);
 
   TestCallbackWithUint32 callback8;
   socket_->NegotiateMaxPendingSendRequests(0, callback8.callback());
   callback8.WaitForResult();
   EXPECT_GT(callback8.result(), 0u);
 
   TestCallbackWithUint32 callback9;
   socket_->NegotiateMaxPendingSendRequests(16, callback9.callback());
   callback9.WaitForResult();
   EXPECT_GT(callback9.result(), 0u);
 }
 
 TEST_F(UDPSocketAppTest, TestReadWrite) {
   TestCallbackWithAddressAndReceiver callback1;
   socket_->Bind(GetLocalHostWithAnyPort(), callback1.callback());
   callback1.WaitForResult();
-  ASSERT_EQ(net::OK, callback1.result()->code);
+  ASSERT_EQ(NETWORK_CODE_OK, callback1.result()->code);
   ASSERT_NE(0u, callback1.net_address()->ipv4->port);
 
   receiver_binding_.Bind(callback1.receiver().Pass());
 
   NetAddressPtr server_addr = callback1.net_address().Clone();
 
   UDPSocketPtr client_socket;
   network_service_->CreateUDPSocket(GetProxy(&client_socket));
 
   TestCallbackWithAddressAndReceiver callback2;
   client_socket->Bind(GetLocalHostWithAnyPort(), callback2.callback());
   callback2.WaitForResult();
-  ASSERT_EQ(net::OK, callback2.result()->code);
+  ASSERT_EQ(NETWORK_CODE_OK, callback2.result()->code);
   ASSERT_NE(0u, callback2.net_address()->ipv4->port);
 
   NetAddressPtr client_addr = callback2.net_address().Clone();
 
   const size_t kDatagramCount = 6;
   const size_t kDatagramSize = 255;
   socket_->ReceiveMore(kDatagramCount);
 
   for (size_t i = 0; i < kDatagramCount; ++i) {
     TestCallback callback;
@@ skipping 14 matching lines @@
     EXPECT_TRUE(result->addr.Equals(client_addr));
     EXPECT_TRUE(result->data.Equals(
         CreateTestMessage(static_cast<uint8_t>(i), kDatagramSize)));
   }
 }
 
 TEST_F(UDPSocketAppTest, TestConnectedReadWrite) {
   TestCallbackWithAddressAndReceiver callback1;
   socket_->Bind(GetLocalHostWithAnyPort(), callback1.callback());
   callback1.WaitForResult();
-  ASSERT_EQ(net::OK, callback1.result()->code);
+  ASSERT_EQ(NETWORK_CODE_OK, callback1.result()->code);
   ASSERT_NE(0u, callback1.net_address()->ipv4->port);
 
   receiver_binding_.Bind(callback1.receiver().Pass());
 
   NetAddressPtr server_addr = callback1.net_address().Clone();
 
   UDPSocketPtr client_socket;
   network_service_->CreateUDPSocket(GetProxy(&client_socket));
 
   TestCallbackWithAddressAndReceiver callback2;
   client_socket->Connect(server_addr.Clone(), callback2.callback());
   callback2.WaitForResult();
-  ASSERT_EQ(net::OK, callback2.result()->code);
+  ASSERT_EQ(NETWORK_CODE_OK, callback2.result()->code);
   ASSERT_NE(0u, callback2.net_address()->ipv4->port);
 
   UDPSocketReceiverImpl client_socket_receiver;
   Binding<UDPSocketReceiver> client_receiver_binding(
       &client_socket_receiver, callback2.receiver().Pass());
 
   NetAddressPtr client_addr = callback2.net_address().Clone();
 
   const size_t kDatagramCount = 6;
   const size_t kDatagramSize = 255;
@@ skipping 46 matching lines @@
         CreateTestMessage(static_cast<uint8_t>(i), kDatagramSize)));
   }
 }
 
 TEST_F(UDPSocketAppTest, TestWrapperReadWrite) {
   UDPSocketWrapper socket(socket_.Pass(), 4, 4);
 
   TestCallbackWithAddress callback1;
   socket.Bind(GetLocalHostWithAnyPort(), callback1.callback());
   callback1.WaitForResult();
-  ASSERT_EQ(net::OK, callback1.result()->code);
+  ASSERT_EQ(NETWORK_CODE_OK, callback1.result()->code);
   ASSERT_NE(0u, callback1.net_address()->ipv4->port);
 
   NetAddressPtr server_addr = callback1.net_address().Clone();
 
   UDPSocketPtr raw_client_socket;
   network_service_->CreateUDPSocket(GetProxy(&raw_client_socket));
   UDPSocketWrapper client_socket(raw_client_socket.Pass(), 4, 4);
 
   TestCallbackWithAddress callback2;
   client_socket.Bind(GetLocalHostWithAnyPort(), callback2.callback());
   callback2.WaitForResult();
-  ASSERT_EQ(net::OK, callback2.result()->code);
+  ASSERT_EQ(NETWORK_CODE_OK, callback2.result()->code);
   ASSERT_NE(0u, callback2.net_address()->ipv4->port);
 
   NetAddressPtr client_addr = callback2.net_address().Clone();
 
   const size_t kDatagramCount = 16;
   const size_t kDatagramSize = 255;
 
   for (size_t i = 1; i < kDatagramCount; ++i) {
     scoped_ptr<TestCallback[]> send_callbacks(new TestCallback[i]);
     scoped_ptr<TestReceiveCallback[]> receive_callbacks(
@@ skipping 19 matching lines @@
     }
   }
 }
 
 TEST_F(UDPSocketAppTest, TestWrapperConnectedReadWrite) {
   UDPSocketWrapper socket(socket_.Pass(), 4, 4);
 
   TestCallbackWithAddress callback1;
   socket.Bind(GetLocalHostWithAnyPort(), callback1.callback());
   callback1.WaitForResult();
-  ASSERT_EQ(net::OK, callback1.result()->code);
+  ASSERT_EQ(NETWORK_CODE_OK, callback1.result()->code);
   ASSERT_NE(0u, callback1.net_address()->ipv4->port);
 
   NetAddressPtr server_addr = callback1.net_address().Clone();
 
   UDPSocketPtr raw_client_socket;
   network_service_->CreateUDPSocket(GetProxy(&raw_client_socket));
   UDPSocketWrapper client_socket(raw_client_socket.Pass(), 4, 4);
 
   TestCallbackWithAddress callback2;
   client_socket.Connect(server_addr.Pass(), callback2.callback());
   callback2.WaitForResult();
-  ASSERT_EQ(net::OK, callback2.result()->code);
+  ASSERT_EQ(NETWORK_CODE_OK, callback2.result()->code);
   ASSERT_NE(0u, callback2.net_address()->ipv4->port);
 
   NetAddressPtr client_addr = callback2.net_address().Clone();
 
   const size_t kDatagramCount = 16;
   const size_t kDatagramSize = 255;
 
   // Test send using a connected socket.
   for (size_t i = 1; i < kDatagramCount; ++i) {
     scoped_ptr<TestCallback[]> send_callbacks(new TestCallback[i]);
@@ skipping 42 matching lines @@
                 receive_callbacks[j].result()->code);
       EXPECT_FALSE(receive_callbacks[j].src_addr());
       EXPECT_TRUE(receive_callbacks[j].data().Equals(
           CreateTestMessage(static_cast<uint8_t>(j), kDatagramSize)));
     }
   }
 }
 
 }  // namespace service
 }  // namespace mojo