Cleanup in //runtime/bin

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"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 // Declare the OS-specific types ahead of defining the generic class.
 #if defined(TARGET_OS_ANDROID)
 #include "bin/socket_android.h"
 #elif defined(TARGET_OS_LINUX)
 #include "bin/socket_linux.h"
 #elif defined(TARGET_OS_MACOS)
 #include "bin/socket_macos.h"
 #elif defined(TARGET_OS_WINDOWS)
 #include "bin/socket_win.h"
 #else
 #error Unknown target os.
 #endif
 #include "bin/thread.h"
 #include "bin/utils.h"
 
-
 namespace dart {
 namespace bin {
 
 union RawAddr {
   struct sockaddr_in in;
   struct sockaddr_in6 in6;
   struct sockaddr_storage ss;
   struct sockaddr addr;
 };
 
@@ skipping 12 matching lines @@
     ADDRESS_ANY_IP_V6,
     ADDRESS_FIRST = ADDRESS_LOOPBACK_IP_V4,
     ADDRESS_LAST = ADDRESS_ANY_IP_V6,
   };
 
   explicit SocketAddress(struct sockaddr* sa);
 
   ~SocketAddress() {}
 
   int GetType() {
-    if (addr_.ss.ss_family == AF_INET6) return TYPE_IPV6;
+    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 ?
+    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 ?
+    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;
+      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;
+      if (b.ss.ss_family != AF_INET6) {
+        return false;
+      }
       return memcmp(&a.in6.sin6_addr,
                     &b.in6.sin6_addr,
                     sizeof(a.in6.sin6_addr)) == 0;
     } else {
       UNREACHABLE();
       return false;
     }
   }
 
   static void GetSockAddr(Dart_Handle obj, RawAddr* addr) {
     Dart_TypedData_Type data_type;
     uint8_t* data = NULL;
     intptr_t len;
     Dart_Handle result = Dart_TypedDataAcquireData(
         obj, &data_type, reinterpret_cast<void**>(&data), &len);
-    if (Dart_IsError(result)) Dart_PropagateError(result);
-    if (data_type != Dart_TypedData_kUint8 ||
-        (len != sizeof(in_addr) && len != sizeof(in6_addr))) {
+    if (Dart_IsError(result)) {
+      Dart_PropagateError(result);
+    }
+    if ((data_type != Dart_TypedData_kUint8) ||
+        ((len != sizeof(in_addr)) && (len != sizeof(in6_addr)))) {
       Dart_PropagateError(
           Dart_NewApiError("Unexpected type for socket address"));
     }
     memset(reinterpret_cast<void*>(addr), 0, sizeof(RawAddr));
     if (len == sizeof(in_addr)) {
       addr->in.sin_family = AF_INET;
       memmove(reinterpret_cast<void *>(&addr->in.sin_addr), data, len);
     } else {
       ASSERT(len == sizeof(in6_addr));
       addr->in6.sin6_family = AF_INET6;
       memmove(reinterpret_cast<void*>(&addr->in6.sin6_addr), data, len);
     }
     Dart_TypedDataReleaseData(obj);
   }
 
   static int16_t FromType(int type) {
-    if (type == TYPE_ANY) return AF_UNSPEC;
-    if (type == TYPE_IPV4) return AF_INET;
-    ASSERT(type == TYPE_IPV6 && "Invalid type");
+    if (type == TYPE_ANY) {
+      return AF_UNSPEC;
+    }
+    if (type == TYPE_IPV4) {
+      return AF_INET;
+    }
+    ASSERT((type == TYPE_IPV6) && "Invalid type");
     return AF_INET6;
   }
 
   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);
     } else {
       return ntohs(addr.in6.sin6_port);
     }
   }
 
   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);
+    if (Dart_IsError(result)) {
+      Dart_PropagateError(result);
+    }
     Dart_Handle err;
     if (addr.addr.sa_family == AF_INET6) {
       err = Dart_ListSetAsBytes(
           result, 0,
           reinterpret_cast<const uint8_t*>(&addr.in6.sin6_addr), len);
     } else {
       err = Dart_ListSetAsBytes(
           result, 0, reinterpret_cast<const uint8_t*>(&addr.in.sin_addr), len);
     }
-    if (Dart_IsError(err)) Dart_PropagateError(err);
+    if (Dart_IsError(err)) {
+      Dart_PropagateError(err);
+    }
     return result;
   }
 
   static CObjectUint8Array* ToCObject(const RawAddr& addr) {
     int in_addr_len = SocketAddress::GetInAddrLength(addr);
     const void* in_addr;
     CObjectUint8Array* data =
         new CObjectUint8Array(CObject::NewUint8Array(in_addr_len));
     if (addr.addr.sa_family == AF_INET6) {
       in_addr = reinterpret_cast<const void*>(&addr.in6.sin6_addr);
     } else {
       in_addr = reinterpret_cast<const void*>(&addr.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);
 };
 
+
 class InterfaceSocketAddress {
  public:
-  explicit InterfaceSocketAddress(struct sockaddr* sa,
-                                  const char* interface_name,
-                                  intptr_t interface_index)
+  InterfaceSocketAddress(struct sockaddr* sa,
+                         const char* interface_name,
+                         intptr_t interface_index)
       : socket_address_(new SocketAddress(sa)),
         interface_name_(interface_name),
         interface_index_(interface_index) {}
 
   ~InterfaceSocketAddress() {
     delete socket_address_;
   }
 
   SocketAddress* socket_address() const { return socket_address_; }
   const char* interface_name() const { return interface_name_; }
   int interface_index() const { return interface_index_; }
 
  private:
   SocketAddress* socket_address_;
   const char* interface_name_;
   intptr_t interface_index_;
 
   DISALLOW_COPY_AND_ASSIGN(InterfaceSocketAddress);
 };
 
+
 template<typename T>
 class AddressList {
  public:
   explicit AddressList(intptr_t count)
       : count_(count),
         addresses_(new T*[count_]) {}
 
   ~AddressList() {
     for (intptr_t i = 0; i < count_; i++) {
       delete addresses_[i];
     }
     delete[] addresses_;
   }
 
   intptr_t count() const { return count_; }
   T* GetAt(intptr_t i) const { return addresses_[i]; }
   void SetAt(intptr_t i, T* addr) { addresses_[i] = addr; }
 
  private:
   const intptr_t count_;
   T** addresses_;
 
   DISALLOW_COPY_AND_ASSIGN(AddressList);
 };
 
+
 class Socket {
  public:
   enum SocketRequest {
     kLookupRequest = 0,
     kListInterfacesRequest = 1,
     kReverseLookupRequest = 2,
   };
 
   static bool Initialize();
   static intptr_t Available(intptr_t fd);
@@ skipping 92 matching lines @@
 
   // 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);
 };
 
+
 class ListeningSocketRegistry {
  private:
   struct OSSocket {
     RawAddr address;
     int port;
     bool v6_only;
     bool shared;
     int ref_count;
     intptr_t socketfd;
 
@@ skipping 56 matching lines @@
   std::map<intptr_t, OSSocket*> sockets_by_port_;
   std::map<intptr_t, OSSocket*> sockets_by_fd_;
   Mutex *mutex_;
 
   typedef std::map<intptr_t, OSSocket*>::iterator SocketsIterator;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ListeningSocketRegistry);
 };
 
-
 }  // namespace bin
 }  // namespace dart
 
 #endif  // BIN_SOCKET_H_