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

runtime/bin/socket.h

 // 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.
 
 #ifndef BIN_SOCKET_H_
 #define BIN_SOCKET_H_
 
 #include <map>
 
 #include "platform/globals.h"
@@ skipping 48 matching lines @@
   ~SocketAddress() {}
 
   int GetType() {
     if (addr_.ss.ss_family == AF_INET6) return TYPE_IPV6;
     return TYPE_IPV4;
   }
 
   const char* as_string() const { return as_string_; }
   const RawAddr& addr() const { return addr_; }
 
-  static intptr_t GetAddrLength(const RawAddr* addr) {
-    ASSERT(addr->ss.ss_family == AF_INET || addr->ss.ss_family == AF_INET6);
-    return addr->ss.ss_family == AF_INET6 ?
+  static intptr_t GetAddrLength(const RawAddr& addr) {
+    ASSERT(addr.ss.ss_family == AF_INET || addr.ss.ss_family == AF_INET6);
+    return addr.ss.ss_family == AF_INET6 ?
         sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in);
   }
 
-  static intptr_t GetInAddrLength(const RawAddr* addr) {
-    ASSERT(addr->ss.ss_family == AF_INET || addr->ss.ss_family == AF_INET6);
-    return addr->ss.ss_family == AF_INET6 ?
+  static intptr_t GetInAddrLength(const RawAddr& addr) {
+    ASSERT(addr.ss.ss_family == AF_INET || addr.ss.ss_family == AF_INET6);
+    return addr.ss.ss_family == AF_INET6 ?
         sizeof(struct in6_addr) : sizeof(struct in_addr);
   }
 
   static bool AreAddressesEqual(const RawAddr& a, const RawAddr& b) {
     if (a.ss.ss_family == AF_INET) {
       if (b.ss.ss_family != AF_INET) return false;
       return memcmp(&a.in.sin_addr, &b.in.sin_addr, sizeof(a.in.sin_addr)) == 0;
     } else if (a.ss.ss_family == AF_INET6) {
       if (b.ss.ss_family != AF_INET6) return false;
       return memcmp(&a.in6.sin6_addr,
@@ skipping 37 matching lines @@
   }
 
   static void SetAddrPort(RawAddr* addr, intptr_t port) {
     if (addr->ss.ss_family == AF_INET) {
       addr->in.sin_port = htons(port);
     } else {
       addr->in6.sin6_port = htons(port);
     }
   }
 
-  static intptr_t GetAddrPort(const RawAddr* addr) {
-    if (addr->ss.ss_family == AF_INET) {
-      return ntohs(addr->in.sin_port);
+  static intptr_t GetAddrPort(const RawAddr& addr) {
+    if (addr.ss.ss_family == AF_INET) {
+      return ntohs(addr.in.sin_port);
     } else {
-      return ntohs(addr->in6.sin6_port);
+      return ntohs(addr.in6.sin6_port);
     }
   }
 
-  static Dart_Handle ToTypedData(RawAddr* raw) {
-    int len = GetInAddrLength(raw);
+  static Dart_Handle ToTypedData(const RawAddr& addr) {
+    int len = GetInAddrLength(addr);
     Dart_Handle result = Dart_NewTypedData(Dart_TypedData_kUint8, len);
     if (Dart_IsError(result)) Dart_PropagateError(result);
     Dart_Handle err;
-    if (raw->addr.sa_family == AF_INET6) {
+    RawAddr& raw = const_cast<RawAddr&>(addr);
+    if (addr.addr.sa_family == AF_INET6) {
       err = Dart_ListSetAsBytes(
-          result, 0, reinterpret_cast<uint8_t*>(&raw->in6.sin6_addr), len);
+          result, 0, reinterpret_cast<uint8_t*>(&raw.in6.sin6_addr), len);
     } else {
       err = Dart_ListSetAsBytes(
-          result, 0, reinterpret_cast<uint8_t*>(&raw->in.sin_addr), len);
+          result, 0, reinterpret_cast<uint8_t*>(&raw.in.sin_addr), len);
     }
     if (Dart_IsError(err)) Dart_PropagateError(err);
     return result;
   }
 
-  static CObjectUint8Array* ToCObject(RawAddr* raw) {
-    int in_addr_len = SocketAddress::GetInAddrLength(raw);
+  static CObjectUint8Array* ToCObject(const RawAddr& addr) {
+    int in_addr_len = SocketAddress::GetInAddrLength(addr);
     void* in_addr;
+    RawAddr& raw = const_cast<RawAddr&>(addr);
     CObjectUint8Array* data =
         new CObjectUint8Array(CObject::NewUint8Array(in_addr_len));
-    if (raw->addr.sa_family == AF_INET6) {
-      in_addr = reinterpret_cast<void*>(&raw->in6.sin6_addr);
+    if (addr.addr.sa_family == AF_INET6) {
+      in_addr = reinterpret_cast<void*>(&raw.in6.sin6_addr);
     } else {
-      in_addr = reinterpret_cast<void*>(&raw->in.sin_addr);
+      in_addr = reinterpret_cast<void*>(&raw.in.sin_addr);
     }
     memmove(data->Buffer(), in_addr, in_addr_len);
     return data;
   }
 
  private:
   char as_string_[INET6_ADDRSTRLEN];
   RawAddr addr_;
 
   DISALLOW_COPY_AND_ASSIGN(SocketAddress);
@@ skipping 55 matching lines @@
   enum SocketRequest {
     kLookupRequest = 0,
     kListInterfacesRequest = 1,
     kReverseLookupRequest = 2,
   };
 
   static bool Initialize();
   static intptr_t Available(intptr_t fd);
   static intptr_t Read(intptr_t fd, void* buffer, intptr_t num_bytes);
   static intptr_t Write(intptr_t fd, const void* buffer, intptr_t num_bytes);
+  // Send data on a socket. The port to send to is specified in the port
+  // component of the passed RawAddr structure. The RawAddr structure is only
+  // used for datagram sockets.
   static intptr_t SendTo(
-      intptr_t fd, const void* buffer, intptr_t num_bytes, RawAddr addr);
+      intptr_t fd, const void* buffer, intptr_t num_bytes, const RawAddr& addr);
   static intptr_t RecvFrom(
       intptr_t fd, void* buffer, intptr_t num_bytes, RawAddr* addr);
-  static intptr_t CreateConnect(const RawAddr& addr,
-                                const intptr_t port);
+  // Creates a socket which is bound and connected. The port to connect to is
+  // specified as the port component of the passed RawAddr structure.
+  static intptr_t CreateConnect(const RawAddr& addr);
+  // Creates a socket which is bound and connected. The port to connect to is
+  // specified as the port component of the passed RawAddr structure.
   static intptr_t CreateBindConnect(const RawAddr& addr,
-                                    const intptr_t port,
                                     const RawAddr& source_addr);
-  static intptr_t CreateBindDatagram(
-      RawAddr* addr, intptr_t port, bool reuseAddress);
+  // Creates a datagram socket which is bound. The port to bind
+  // to is specified as the port component of the RawAddr structure.
+  static intptr_t CreateBindDatagram(const RawAddr& addr, bool reuseAddress);
   static intptr_t GetPort(intptr_t fd);
   static SocketAddress* GetRemotePeer(intptr_t fd, intptr_t* port);
   static void GetError(intptr_t fd, OSError* os_error);
   static int GetType(intptr_t fd);
   static intptr_t GetStdioHandle(intptr_t num);
   static void Close(intptr_t fd);
   static bool GetNoDelay(intptr_t fd, bool* enabled);
   static bool SetNoDelay(intptr_t fd, bool enabled);
   static bool GetMulticastLoop(intptr_t fd, intptr_t protocol, bool* enabled);
   static bool SetMulticastLoop(intptr_t fd, intptr_t protocol, bool enabled);
   static bool GetMulticastHops(intptr_t fd, intptr_t protocol, int* value);
   static bool SetMulticastHops(intptr_t fd, intptr_t protocol, int value);
   static bool GetBroadcast(intptr_t fd, bool* value);
   static bool SetBroadcast(intptr_t fd, bool value);
-  static bool JoinMulticast(
-      intptr_t fd, RawAddr* addr, RawAddr* interface, int interfaceIndex);
-  static bool LeaveMulticast(
-      intptr_t fd, RawAddr* addr, RawAddr* interface, int interfaceIndex);
+  static bool JoinMulticast(intptr_t fd,
+                            const RawAddr& addr,
+                            const RawAddr& interface,
+                            int interfaceIndex);
+  static bool LeaveMulticast(intptr_t fd,
+                             const RawAddr& addr,
+                             const RawAddr& interface,
+                             int interfaceIndex);
 
   // Perform a hostname lookup. Returns a AddressList of SocketAddress's.
   static AddressList<SocketAddress>* LookupAddress(const char* host,
                                                    int type,
                                                    OSError** os_error);
 
-  static bool ReverseLookup(RawAddr addr,
+  static bool ReverseLookup(const RawAddr& addr,
                             char* host,
                             intptr_t host_len,
                             OSError** os_error);
 
   static bool ParseAddress(int type, const char* address, RawAddr* addr);
-  static bool FormatNumericAddress(RawAddr* addr, char* address, int len);
+  static bool FormatNumericAddress(const RawAddr& addr, char* address, int len);
 
   // List interfaces. Returns a AddressList of InterfaceSocketAddress's.
   static AddressList<InterfaceSocketAddress>* ListInterfaces(
       int type,
       OSError** os_error);
 
   static CObject* LookupRequest(const CObjectArray& request);
   static CObject* ListInterfacesRequest(const CObjectArray& request);
   static CObject* ReverseLookupRequest(const CObjectArray& request);
 
   static Dart_Port GetServicePort();
 
   static void SetSocketIdNativeField(Dart_Handle socket, intptr_t id);
   static intptr_t GetSocketIdNativeField(Dart_Handle socket);
 
  private:
   DISALLOW_ALLOCATION();
   DISALLOW_IMPLICIT_CONSTRUCTORS(Socket);
 };
 
 
 class ServerSocket {
  public:
   static const intptr_t kTemporaryFailure = -2;
 
   static intptr_t Accept(intptr_t fd);
 
+  // Creates a socket which is bound and listens. The port to listen on is
+  // specified in the port component of the passed RawAddr structure.
+  //
   // Returns a positive integer if the call is successful. In case of failure
   // it returns:
   //
   //   -1: system error (errno set)
   //   -5: invalid bindAddress
-  static intptr_t CreateBindListen(RawAddr addr,
-                                   intptr_t port,
+  static intptr_t CreateBindListen(const RawAddr& addr,
                                    intptr_t backlog,
                                    bool v6_only = false);
 
   // Start accepting on a newly created listening socket. If it was unable to
   // start accepting incoming sockets, the fd is invalidated.
   static bool StartAccept(intptr_t fd);
 
  private:
   DISALLOW_ALLOCATION();
   DISALLOW_IMPLICIT_CONSTRUCTORS(ServerSocket);
@@ skipping 31 matching lines @@
 
   ~ListeningSocketRegistry() {
     delete mutex_;
     mutex_ = NULL;
   }
 
   // This function should be called from a dart runtime call in order to create
   // a new (potentially shared) socket.
   Dart_Handle CreateBindListen(Dart_Handle socket_object,
                                RawAddr addr,
-                               intptr_t port,
                                intptr_t backlog,
                                bool v6_only,
                                bool shared);
 
   // This should be called from the event handler for every kCloseEvent it gets
   // on listening sockets.
   //
   // Returns `true` if the last reference has been dropped and the underlying
   // socket can be closed.
   //
@@ skipping 29 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ListeningSocketRegistry);
 };
 
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // BIN_SOCKET_H_