Cleanup in //runtime/bin

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/dartutils.h"
 #include "bin/io_buffer.h"
 #include "bin/isolate_data.h"
-#include "bin/dartutils.h"
+#include "bin/lockers.h"
 #include "bin/socket.h"
 #include "bin/thread.h"
-#include "bin/lockers.h"
 #include "bin/utils.h"
 
 #include "platform/globals.h"
 #include "platform/utils.h"
 
 #include "include/dart_api.h"
 
 namespace dart {
 namespace bin {
 
@@ skipping 32 matching lines @@
   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`, ...
-
     OSSocket *os_socket = it->second;
     OSSocket *os_socket_same_addr = findOSSocketWithAddress(os_socket, addr);
 
     if (os_socket_same_addr != NULL) {
       if (!os_socket_same_addr->shared || !shared) {
         OSError os_error(-1,
                          "The shared flag to bind() needs to be `true` if "
                          "binding multiple times on the same (address, port) "
                          "combination.",
                         OSError::kUnknown);
@@ skipping 65 matching lines @@
       sockets_by_fd_.erase(socketfd);
 
       OSSocket *prev = NULL;
       OSSocket *current = sockets_by_port_[os_socket->port];
       while (current != os_socket) {
         ASSERT(current != NULL);
         prev = current;
         current = current->next;
       }
 
-      if (prev == NULL && current->next == NULL) {
+      if ((prev == NULL) && (current->next == NULL)) {
         // Remove last element from the list.
         sockets_by_port_.erase(os_socket->port);
       } else if (prev == NULL) {
         // Remove first element of the list.
         sockets_by_port_[os_socket->port] = current->next;
       } else {
         // Remove element from the list which is not the first one.
         prev->next = os_socket->next;
       }
 
@@ skipping 104 matching lines @@
   static bool short_socket_reads = Dart_IsVMFlagSet("short_socket_read");
   intptr_t socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   int64_t length = 0;
   if (DartUtils::GetInt64Value(Dart_GetNativeArgument(args, 1), &length)) {
     if (short_socket_reads) {
       length = (length + 1) / 2;
     }
     uint8_t* buffer = NULL;
     Dart_Handle result = IOBuffer::Allocate(length, &buffer);
-    if (Dart_IsError(result)) Dart_PropagateError(result);
+    if (Dart_IsError(result)) {
+      Dart_PropagateError(result);
+    }
     ASSERT(buffer != NULL);
     intptr_t bytes_read = Socket::Read(socket, buffer, length);
     if (bytes_read == length) {
       Dart_SetReturnValue(args, result);
     } else if (bytes_read > 0) {
       uint8_t* new_buffer = NULL;
       Dart_Handle new_result = IOBuffer::Allocate(bytes_read, &new_buffer);
-      if (Dart_IsError(new_result)) Dart_PropagateError(new_result);
+      if (Dart_IsError(new_result)) {
+        Dart_PropagateError(new_result);
+      }
       ASSERT(new_buffer != NULL);
       memmove(new_buffer, buffer, bytes_read);
       Dart_SetReturnValue(args, new_result);
     } else if (bytes_read == 0) {
       // On MacOS when reading from a tty Ctrl-D will result in reading one
       // less byte then reported as available.
       Dart_SetReturnValue(args, Dart_Null());
     } else {
       ASSERT(bytes_read == -1);
       Dart_SetReturnValue(args, DartUtils::NewDartOSError());
@@ skipping 26 matching lines @@
   }
   if (bytes_read < 0) {
     ASSERT(bytes_read == -1);
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
     return;
   }
   // 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);
+  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);
   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);
 
   // 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]);
+  if (Dart_IsError(dart_args[1])) {
+    Dart_PropagateError(dart_args[1]);
+  }
   dart_args[2] = SocketAddress::ToTypedData(addr);
   dart_args[3] = Dart_NewInteger(port);
-  if (Dart_IsError(dart_args[3])) Dart_PropagateError(dart_args[3]);
+  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);
+  if (Dart_IsError(io_lib)) {
+    Dart_PropagateError(io_lib);
+  }
   Dart_Handle result =
       Dart_Invoke(io_lib,
                   DartUtils::NewString("_makeDatagram"),
                   kNumArgs,
                   dart_args);
   Dart_SetReturnValue(args, result);
 }
 
 
 void FUNCTION_NAME(Socket_WriteList)(Dart_NativeArguments args) {
   static bool short_socket_writes = Dart_IsVMFlagSet("short_socket_write");
   intptr_t socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   Dart_Handle buffer_obj = Dart_GetNativeArgument(args, 1);
   ASSERT(Dart_IsList(buffer_obj));
   intptr_t offset =
       DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 2));
   intptr_t length =
       DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 3));
   bool short_write = false;
   if (short_socket_writes) {
-    if (length > 1) short_write = true;
+    if (length > 1) {
+      short_write = true;
+    }
     length = (length + 1) / 2;
   }
   Dart_TypedData_Type type;
   uint8_t* buffer = NULL;
   intptr_t len;
   Dart_Handle result = Dart_TypedDataAcquireData(
       buffer_obj, &type, reinterpret_cast<void**>(&buffer), &len);
-  if (Dart_IsError(result)) Dart_PropagateError(result);
+  if (Dart_IsError(result)) {
+    Dart_PropagateError(result);
+  }
   ASSERT((offset + length) <= len);
   buffer += offset;
   intptr_t bytes_written = Socket::Write(socket, buffer, length);
   if (bytes_written >= 0) {
     Dart_TypedDataReleaseData(buffer_obj);
     if (short_write) {
       // If the write was forced 'short', indicate by returning the negative
       // number of bytes. A forced short write may not trigger a write event.
       Dart_SetReturnValue(args, Dart_NewInteger(-bytes_written));
     } else {
@@ skipping 23 matching lines @@
   int64_t port = DartUtils::GetInt64ValueCheckRange(
       Dart_GetNativeArgument(args, 5),
       0,
       65535);
   SocketAddress::SetAddrPort(&addr, port);
   Dart_TypedData_Type type;
   uint8_t* buffer = NULL;
   intptr_t len;
   Dart_Handle result = Dart_TypedDataAcquireData(
       buffer_obj, &type, reinterpret_cast<void**>(&buffer), &len);
-  if (Dart_IsError(result)) Dart_PropagateError(result);
+  if (Dart_IsError(result)) {
+    Dart_PropagateError(result);
+  }
   ASSERT((offset + length) <= len);
   buffer += offset;
   intptr_t bytes_written = Socket::SendTo(socket, buffer, length, addr);
   if (bytes_written >= 0) {
     Dart_TypedDataReleaseData(buffer_obj);
     Dart_SetReturnValue(args, Dart_NewInteger(bytes_written));
   } else {
     // Extract OSError before we release data, as it may override the error.
     OSError os_error;
     Dart_TypedDataReleaseData(buffer_obj);
@@ skipping 69 matching lines @@
 void FUNCTION_NAME(Socket_GetStdioHandle)(Dart_NativeArguments args) {
   int64_t num = DartUtils::GetInt64ValueCheckRange(
       Dart_GetNativeArgument(args, 1), 0, 2);
   intptr_t socket = Socket::GetStdioHandle(num);
   Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 0), socket);
   Dart_SetReturnValue(args, Dart_NewBoolean(socket >= 0));
 }
 
 
 void FUNCTION_NAME(Socket_GetSocketId)(Dart_NativeArguments args) {
-  intptr_t id =
-      Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
+  intptr_t id = Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   Dart_SetReturnValue(args, Dart_NewInteger(id));
 }
 
 
 void FUNCTION_NAME(Socket_SetSocketId)(Dart_NativeArguments args) {
-  intptr_t id =
-      DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 1));
+  intptr_t id = DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 1));
   Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 0), id);
 }
 
 
 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,
@@ skipping 22 matching lines @@
     Dart_SetReturnValue(args, Dart_True());
   } else if (new_socket == ServerSocket::kTemporaryFailure) {
     Dart_SetReturnValue(args, Dart_False());
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
 }
 
 
 CObject* Socket::LookupRequest(const CObjectArray& request) {
-  if (request.Length() == 2 &&
+  if ((request.Length() == 2) &&
       request[0]->IsString() &&
       request[1]->IsInt32()) {
     CObjectString host(request[0]);
     CObjectInt32 type(request[1]);
     CObject* result = NULL;
     OSError* os_error = NULL;
     AddressList<SocketAddress>* addresses =
         Socket::LookupAddress(host.CString(), type.Value(), &os_error);
     if (addresses != NULL) {
       CObjectArray* array = new CObjectArray(
@@ skipping 23 matching lines @@
       result = CObject::NewOSError(os_error);
       delete os_error;
     }
     return result;
   }
   return CObject::IllegalArgumentError();
 }
 
 
 CObject* Socket::ReverseLookupRequest(const CObjectArray& request) {
-  if (request.Length() == 1 &&
+  if ((request.Length() == 1) &&
       request[0]->IsTypedData()) {
     CObjectUint8Array addr_object(request[0]);
     RawAddr addr;
     int len = addr_object.Length();
     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),
               addr_object.Buffer(),
               len);
@@ skipping 14 matching lines @@
       CObject* result = CObject::NewOSError(os_error);
       delete os_error;
       return result;
     }
   }
   return CObject::IllegalArgumentError();
 }
 
 
 CObject* Socket::ListInterfacesRequest(const CObjectArray& request) {
-  if (request.Length() == 1 &&
+  if ((request.Length() == 1) &&
       request[0]->IsInt32()) {
     CObjectInt32 type(request[0]);
     CObject* result = NULL;
     OSError* os_error = NULL;
     AddressList<InterfaceSocketAddress>* addresses = Socket::ListInterfaces(
         type.Value(), &os_error);
     if (addresses != NULL) {
       CObjectArray* array = new CObjectArray(
           CObject::NewArray(addresses->count() + 1));
       array->SetAt(0, new CObjectInt32(CObject::NewInt32(0)));
@@ skipping 172 matching lines @@
     Dart_SetReturnValue(args, Dart_Null());
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
 }
 
 
 void Socket::SetSocketIdNativeField(Dart_Handle socket, intptr_t id) {
   Dart_Handle err =
       Dart_SetNativeInstanceField(socket, kSocketIdNativeField, id);
-  if (Dart_IsError(err)) Dart_PropagateError(err);
+  if (Dart_IsError(err)) {
+    Dart_PropagateError(err);
+  }
 }
 
 
 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);
+  if (Dart_IsError(err)) {
+    Dart_PropagateError(err);
+  }
   return socket;
 }
 
 }  // namespace bin
 }  // namespace dart