Reafctor to use 'const RawAddr&' or 'RawAddr*' in the eventhandler code

runtime/bin/socket.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "bin/io_buffer.h"
 #include "bin/isolate_data.h"
 #include "bin/dartutils.h"
 #include "bin/socket.h"
 #include "bin/thread.h"
 #include "bin/lockers.h"
@@ skipping 25 matching lines @@
 
 
 void ListeningSocketRegistry::Cleanup() {
   delete globalTcpListeningSocketRegistry;
   globalTcpListeningSocketRegistry = NULL;
 }
 
 
 Dart_Handle ListeningSocketRegistry::CreateBindListen(Dart_Handle socket_object,
                                                       RawAddr addr,
-                                                      intptr_t port,
                                                       intptr_t backlog,
                                                       bool v6_only,
                                                       bool shared) {
   MutexLocker ml(ListeningSocketRegistry::mutex_);
 
+  intptr_t port = SocketAddress::GetAddrPort(addr);
+
   SocketsIterator it = sockets_by_port_.find(port);
   OSSocket *first_os_socket = NULL;
   if (it != sockets_by_port_.end()) {
     first_os_socket = it->second;
   }
 
   if (first_os_socket != NULL) {
     // There is already a socket listening on this port. We need to ensure
     // that if there is one also listening on the same address, it was created
     // with `shared = true`, ...
@@ skipping 25 matching lines @@
       os_socket->ref_count++;
 
       // We set as a side-effect the file descriptor on the dart socket_object.
       Socket::SetSocketIdNativeField(socket_object, os_socket->socketfd);
 
       return Dart_True();
     }
   }
 
   // There is no socket listening on that (address, port), so we create new one.
-  intptr_t socketfd = ServerSocket::CreateBindListen(
-      addr, port, backlog, v6_only);
+  intptr_t socketfd = ServerSocket::CreateBindListen(addr, backlog, v6_only);
   if (socketfd == -5) {
     OSError os_error(-1, "Invalid host", OSError::kUnknown);
     return DartUtils::NewDartOSError(&os_error);
   }
   if (socketfd < 0) {
     OSError error;
     return DartUtils::NewDartOSError(&error);
   }
   if (!ServerSocket::StartAccept(socketfd)) {
     OSError os_error(-1, "Failed to start accept", OSError::kUnknown);
@@ skipping 85 matching lines @@
                                           : SocketAddress::TYPE_IPV6;
   if (type == SocketAddress::TYPE_IPV4) {
     raw.addr.sa_family = AF_INET;
   } else {
     raw.addr.sa_family = AF_INET6;
   }
   bool ok = Socket::ParseAddress(type, address, &raw);
   if (!ok) {
     Dart_SetReturnValue(args, Dart_Null());
   } else {
-    Dart_SetReturnValue(args, SocketAddress::ToTypedData(&raw));
+    Dart_SetReturnValue(args, SocketAddress::ToTypedData(raw));
   }
 }
 
 
 void FUNCTION_NAME(Socket_CreateConnect)(Dart_NativeArguments args) {
   RawAddr addr;
   SocketAddress::GetSockAddr(Dart_GetNativeArgument(args, 1), &addr);
   Dart_Handle port_arg = Dart_GetNativeArgument(args, 2);
   int64_t port = DartUtils::GetInt64ValueCheckRange(port_arg, 0, 65535);
-  intptr_t socket = Socket::CreateConnect(addr, static_cast<intptr_t>(port));
+  SocketAddress::SetAddrPort(&addr, static_cast<intptr_t>(port));
+  intptr_t socket = Socket::CreateConnect(addr);
   OSError error;
   if (socket >= 0) {
     Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 0), socket);
     Dart_SetReturnValue(args, Dart_True());
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError(&error));
   }
 }
 
 
 void FUNCTION_NAME(Socket_CreateBindConnect)(Dart_NativeArguments args) {
   RawAddr addr;
   SocketAddress::GetSockAddr(Dart_GetNativeArgument(args, 1), &addr);
   Dart_Handle port_arg = Dart_GetNativeArgument(args, 2);
   int64_t port = DartUtils::GetInt64ValueCheckRange(port_arg, 0, 65535);
+  SocketAddress::SetAddrPort(&addr, static_cast<intptr_t>(port));
   RawAddr sourceAddr;
   SocketAddress::GetSockAddr(Dart_GetNativeArgument(args, 3), &sourceAddr);
-  intptr_t socket = Socket::CreateBindConnect(
-      addr, static_cast<intptr_t>(port), sourceAddr);
+  intptr_t socket = Socket::CreateBindConnect(addr, sourceAddr);
   OSError error;
   if (socket >= 0) {
     Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 0), socket);
     Dart_SetReturnValue(args, Dart_True());
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError(&error));
   }
 }
 
 
 void FUNCTION_NAME(Socket_CreateBindDatagram)(Dart_NativeArguments args) {
   RawAddr addr;
   SocketAddress::GetSockAddr(Dart_GetNativeArgument(args, 1), &addr);
   Dart_Handle port_arg = Dart_GetNativeArgument(args, 2);
   int64_t port = DartUtils::GetInt64ValueCheckRange(port_arg, 0, 65535);
+  SocketAddress::SetAddrPort(&addr, port);
   bool reuse_addr = DartUtils::GetBooleanValue(Dart_GetNativeArgument(args, 3));
-  intptr_t socket = Socket::CreateBindDatagram(&addr,
-                                               static_cast<intptr_t>(port),
-                                               reuse_addr);
+  intptr_t socket = Socket::CreateBindDatagram(addr, reuse_addr);
   if (socket >= 0) {
     Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 0), socket);
     Dart_SetReturnValue(args, Dart_True());
   } else {
     OSError error;
     Dart_SetReturnValue(args, DartUtils::NewDartOSError(&error));
   }
 }
 
 
@@ skipping 77 matching lines @@
   }
   // Datagram data read. Copy into buffer of the exact size,
   ASSERT(bytes_read > 0);
   uint8_t* data_buffer = NULL;
   Dart_Handle data = IOBuffer::Allocate(bytes_read, &data_buffer);
   if (Dart_IsError(data)) Dart_PropagateError(data);
   ASSERT(data_buffer != NULL);
   memmove(data_buffer, isolate_data->udp_receive_buffer, bytes_read);
 
   // Get the port and clear it in the sockaddr structure.
-  int port = SocketAddress::GetAddrPort(&addr);
+  int port = SocketAddress::GetAddrPort(addr);
   if (addr.addr.sa_family == AF_INET) {
     addr.in.sin_port = 0;
   } else {
     ASSERT(addr.addr.sa_family == AF_INET6);
     addr.in6.sin6_port = 0;
   }
   // Format the address to a string using the numeric format.
   char numeric_address[INET6_ADDRSTRLEN];
-  Socket::FormatNumericAddress(&addr, numeric_address, INET6_ADDRSTRLEN);
+  Socket::FormatNumericAddress(addr, numeric_address, INET6_ADDRSTRLEN);
 
   // Create a Datagram object with the data and sender address and port.
   const int kNumArgs = 4;
   Dart_Handle dart_args[kNumArgs];
   dart_args[0] = data;
   dart_args[1] = Dart_NewStringFromCString(numeric_address);
   if (Dart_IsError(dart_args[1])) Dart_PropagateError(dart_args[1]);
-  dart_args[2] = SocketAddress::ToTypedData(&addr);
+  dart_args[2] = SocketAddress::ToTypedData(addr);
   dart_args[3] = Dart_NewInteger(port);
   if (Dart_IsError(dart_args[3])) Dart_PropagateError(dart_args[3]);
   // TODO(sgjesse): Cache the _makeDatagram function somewhere.
   Dart_Handle io_lib =
       Dart_LookupLibrary(DartUtils::NewString("dart:io"));
   if (Dart_IsError(io_lib)) Dart_PropagateError(io_lib);
   Dart_Handle result =
       Dart_Invoke(io_lib,
                   DartUtils::NewString("_makeDatagram"),
                   kNumArgs,
@@ skipping 103 matching lines @@
   intptr_t port = 0;
   SocketAddress* addr = Socket::GetRemotePeer(socket, &port);
   if (addr != NULL) {
     Dart_Handle list = Dart_NewList(2);
 
     Dart_Handle entry = Dart_NewList(3);
     Dart_ListSetAt(entry, 0, Dart_NewInteger(addr->GetType()));
     Dart_ListSetAt(entry, 1, Dart_NewStringFromCString(addr->as_string()));
 
     RawAddr raw = addr->addr();
-    intptr_t data_length = SocketAddress::GetAddrLength(&raw);
+    intptr_t data_length = SocketAddress::GetAddrLength(raw);
     Dart_Handle data = Dart_NewTypedData(Dart_TypedData_kUint8, data_length);
     Dart_ListSetAsBytes(data, 0, reinterpret_cast<uint8_t*>(&raw), data_length);
     Dart_ListSetAt(entry, 2, data);
 
     Dart_ListSetAt(list, 0, entry);
     Dart_ListSetAt(list, 1, Dart_NewInteger(port));
     Dart_SetReturnValue(args, list);
     delete addr;
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
@@ skipping 46 matching lines @@
 }
 
 
 void FUNCTION_NAME(ServerSocket_CreateBindListen)(Dart_NativeArguments args) {
   RawAddr addr;
   SocketAddress::GetSockAddr(Dart_GetNativeArgument(args, 1), &addr);
   int64_t port = DartUtils::GetInt64ValueCheckRange(
       Dart_GetNativeArgument(args, 2),
       0,
       65535);
+  SocketAddress::SetAddrPort(&addr, port);
   int64_t backlog = DartUtils::GetInt64ValueCheckRange(
       Dart_GetNativeArgument(args, 3),
       0,
       65535);
   bool v6_only = DartUtils::GetBooleanValue(Dart_GetNativeArgument(args, 4));
   bool shared = DartUtils::GetBooleanValue(Dart_GetNativeArgument(args, 5));
 
   Dart_Handle socket_object = Dart_GetNativeArgument(args, 0);
   Dart_Handle result = ListeningSocketRegistry::Instance()->CreateBindListen(
-      socket_object, addr, port, backlog, v6_only, shared);
+      socket_object, addr, backlog, v6_only, shared);
   Dart_SetReturnValue(args, result);
 }
 
 
 void FUNCTION_NAME(ServerSocket_Accept)(Dart_NativeArguments args) {
   intptr_t socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   intptr_t new_socket = ServerSocket::Accept(socket);
   if (new_socket >= 0) {
     Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 1), new_socket);
@@ skipping 26 matching lines @@
 
         CObjectInt32* type = new CObjectInt32(
             CObject::NewInt32(addr->GetType()));
         entry->SetAt(0, type);
 
         CObjectString* as_string = new CObjectString(CObject::NewString(
             addr->as_string()));
         entry->SetAt(1, as_string);
 
         RawAddr raw = addr->addr();
-        CObjectUint8Array* data = SocketAddress::ToCObject(&raw);
+        CObjectUint8Array* data = SocketAddress::ToCObject(raw);
         entry->SetAt(2, data);
 
         array->SetAt(i + 1, entry);
       }
       result = array;
       delete addresses;
     } else {
       result = CObject::NewOSError(os_error);
       delete os_error;
     }
@@ skipping 57 matching lines @@
 
         CObjectInt32* type = new CObjectInt32(
             CObject::NewInt32(addr->GetType()));
         entry->SetAt(0, type);
 
         CObjectString* as_string = new CObjectString(CObject::NewString(
             addr->as_string()));
         entry->SetAt(1, as_string);
 
         RawAddr raw = addr->addr();
-        CObjectUint8Array* data = SocketAddress::ToCObject(&raw);
+        CObjectUint8Array* data = SocketAddress::ToCObject(raw);
         entry->SetAt(2, data);
 
         CObjectString* interface_name = new CObjectString(CObject::NewString(
             interface->interface_name()));
         entry->SetAt(3, interface_name);
 
         CObjectInt64* interface_index = new CObjectInt64(CObject::NewInt64(
             interface->interface_index()));
         entry->SetAt(4, interface_index);
 
@@ skipping 117 matching lines @@
   intptr_t socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   RawAddr addr;
   SocketAddress::GetSockAddr(Dart_GetNativeArgument(args, 1), &addr);
   RawAddr interface;
   if (Dart_GetNativeArgument(args, 2) != Dart_Null()) {
     SocketAddress::GetSockAddr(Dart_GetNativeArgument(args, 2), &interface);
   }
   int interfaceIndex =
       DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 3));
-  if (Socket::JoinMulticast(socket, &addr, &interface, interfaceIndex)) {
+  if (Socket::JoinMulticast(socket, addr, interface, interfaceIndex)) {
     Dart_SetReturnValue(args, Dart_Null());
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
 }
 
 
 void FUNCTION_NAME(Socket_LeaveMulticast)(Dart_NativeArguments args) {
   intptr_t socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   RawAddr addr;
   SocketAddress::GetSockAddr(Dart_GetNativeArgument(args, 1), &addr);
   RawAddr interface;
   if (Dart_GetNativeArgument(args, 2) != Dart_Null()) {
     SocketAddress::GetSockAddr(Dart_GetNativeArgument(args, 2), &interface);
   }
   int interfaceIndex =
       DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 3));
-  if (Socket::LeaveMulticast(socket, &addr, &interface, interfaceIndex)) {
+  if (Socket::LeaveMulticast(socket, addr, interface, interfaceIndex)) {
     Dart_SetReturnValue(args, Dart_Null());
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
 }
 
 
 void FUNCTION_NAME(Socket_MarkSocketAsSharedHack)(Dart_NativeArguments args) {
   intptr_t socketfd =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
@@ skipping 13 matching lines @@
 intptr_t Socket::GetSocketIdNativeField(Dart_Handle socket_obj) {
   intptr_t socket = 0;
   Dart_Handle err =
       Dart_GetNativeInstanceField(socket_obj, kSocketIdNativeField, &socket);
   if (Dart_IsError(err)) Dart_PropagateError(err);
   return socket;
 }
 
 }  // namespace bin
 }  // namespace dart