VM: Re-format to use at most one newline between functions

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.
 
 #if !defined(DART_IO_DISABLED)
 
 #include "bin/socket.h"
 
 #include "bin/dartutils.h"
 #include "bin/eventhandler.h"
@@ skipping 17 matching lines @@
 
 bool short_socket_read = false;
 
 bool short_socket_write = false;
 
 void ListeningSocketRegistry::Initialize() {
   ASSERT(globalTcpListeningSocketRegistry == NULL);
   globalTcpListeningSocketRegistry = new ListeningSocketRegistry();
 }
 
-
 ListeningSocketRegistry* ListeningSocketRegistry::Instance() {
   return globalTcpListeningSocketRegistry;
 }
 
-
 void ListeningSocketRegistry::Cleanup() {
   delete globalTcpListeningSocketRegistry;
   globalTcpListeningSocketRegistry = NULL;
 }
 
-
 ListeningSocketRegistry::OSSocket* ListeningSocketRegistry::LookupByPort(
     intptr_t port) {
   HashMap::Entry* entry = sockets_by_port_.Lookup(
       GetHashmapKeyFromIntptr(port), GetHashmapHashFromIntptr(port), false);
   if (entry == NULL) {
     return NULL;
   }
   return reinterpret_cast<OSSocket*>(entry->value);
 }
 
-
 void ListeningSocketRegistry::InsertByPort(intptr_t port, OSSocket* socket) {
   HashMap::Entry* entry = sockets_by_port_.Lookup(
       GetHashmapKeyFromIntptr(port), GetHashmapHashFromIntptr(port), true);
   ASSERT(entry != NULL);
   entry->value = reinterpret_cast<void*>(socket);
 }
 
-
 void ListeningSocketRegistry::RemoveByPort(intptr_t port) {
   sockets_by_port_.Remove(GetHashmapKeyFromIntptr(port),
                           GetHashmapHashFromIntptr(port));
 }
 
-
 ListeningSocketRegistry::OSSocket* ListeningSocketRegistry::LookupByFd(
     Socket* fd) {
   HashMap::Entry* entry = sockets_by_fd_.Lookup(
       GetHashmapKeyFromIntptr(reinterpret_cast<intptr_t>(fd)),
       GetHashmapHashFromIntptr(reinterpret_cast<intptr_t>(fd)), false);
   if (entry == NULL) {
     return NULL;
   }
   return reinterpret_cast<OSSocket*>(entry->value);
 }
 
-
 void ListeningSocketRegistry::InsertByFd(Socket* fd, OSSocket* socket) {
   HashMap::Entry* entry = sockets_by_fd_.Lookup(
       GetHashmapKeyFromIntptr(reinterpret_cast<intptr_t>(fd)),
       GetHashmapHashFromIntptr(reinterpret_cast<intptr_t>(fd)), true);
   ASSERT(entry != NULL);
   entry->value = reinterpret_cast<void*>(socket);
 }
 
-
 void ListeningSocketRegistry::RemoveByFd(Socket* fd) {
   sockets_by_fd_.Remove(
       GetHashmapKeyFromIntptr(reinterpret_cast<intptr_t>(fd)),
       GetHashmapHashFromIntptr(reinterpret_cast<intptr_t>(fd)));
 }
 
-
 Dart_Handle ListeningSocketRegistry::CreateBindListen(Dart_Handle socket_object,
                                                       RawAddr addr,
                                                       intptr_t backlog,
                                                       bool v6_only,
                                                       bool shared) {
   MutexLocker ml(mutex_);
 
   OSSocket* first_os_socket = NULL;
   intptr_t port = SocketAddress::GetAddrPort(addr);
   if (port > 0) {
@@ skipping 84 matching lines @@
   InsertByPort(allocated_port, os_socket);
   InsertByFd(socketfd, os_socket);
 
   // We set as a side-effect the port on the dart socket_object.
   Socket::ReuseSocketIdNativeField(socket_object, socketfd,
                                    Socket::kFinalizerListening);
 
   return Dart_True();
 }
 
-
 bool ListeningSocketRegistry::CloseOneSafe(OSSocket* os_socket,
                                            bool update_hash_maps) {
   ASSERT(!mutex_->TryLock());
   ASSERT(os_socket != NULL);
   ASSERT(os_socket->ref_count > 0);
   os_socket->ref_count--;
   if (os_socket->ref_count > 0) {
     return false;
   }
   if (update_hash_maps) {
@@ skipping 18 matching lines @@
       // Remove element from the list which is not the first one.
       prev->next = os_socket->next;
     }
   }
 
   ASSERT(os_socket->ref_count == 0);
   delete os_socket;
   return true;
 }
 
-
 void ListeningSocketRegistry::CloseAllSafe() {
   MutexLocker ml(mutex_);
 
   for (HashMap::Entry* cursor = sockets_by_fd_.Start(); cursor != NULL;
        cursor = sockets_by_fd_.Next(cursor)) {
     CloseOneSafe(reinterpret_cast<OSSocket*>(cursor->value), false);
   }
 }
 
-
 bool ListeningSocketRegistry::CloseSafe(Socket* socketfd) {
   ASSERT(!mutex_->TryLock());
   OSSocket* os_socket = LookupByFd(socketfd);
   if (os_socket != NULL) {
     return CloseOneSafe(os_socket, true);
   } else {
     // A finalizer may direct the event handler to close a listening socket
     // that it has never seen before. In this case, we return true to direct
     // the eventhandler to clean up the socket.
     return true;
   }
 }
 
-
 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);
   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,
                                    Socket::kFinalizerNormal);
     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, sourceAddr);
   OSError error;
   if (socket >= 0) {
     Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 0), socket,
                                    Socket::kFinalizerNormal);
     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, reuse_addr);
   if (socket >= 0) {
     Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 0), socket,
                                    Socket::kFinalizerNormal);
     Dart_SetReturnValue(args, Dart_True());
   } else {
     OSError error;
     Dart_SetReturnValue(args, DartUtils::NewDartOSError(&error));
   }
 }
 
-
 void FUNCTION_NAME(Socket_Available)(Dart_NativeArguments args) {
   Socket* socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   intptr_t available = SocketBase::Available(socket->fd());
   if (available >= 0) {
     Dart_SetReturnValue(args, Dart_NewInteger(available));
   } else {
     // Available failed. Mark socket as having data, to trigger a future read
     // event where the actual error can be reported.
     Dart_SetReturnValue(args, Dart_NewInteger(1));
   }
 }
 
-
 void FUNCTION_NAME(Socket_Read)(Dart_NativeArguments args) {
   Socket* socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   int64_t length = 0;
   if (DartUtils::GetInt64Value(Dart_GetNativeArgument(args, 1), &length)) {
     if (short_socket_read) {
       length = (length + 1) / 2;
     }
     uint8_t* buffer = NULL;
     Dart_Handle result = IOBuffer::Allocate(length, &buffer);
@@ skipping 21 matching lines @@
     } else {
       ASSERT(bytes_read == -1);
       Dart_SetReturnValue(args, DartUtils::NewDartOSError());
     }
   } else {
     OSError os_error(-1, "Invalid argument", OSError::kUnknown);
     Dart_SetReturnValue(args, DartUtils::NewDartOSError(&os_error));
   }
 }
 
-
 void FUNCTION_NAME(Socket_RecvFrom)(Dart_NativeArguments args) {
   Socket* socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
 
   // TODO(sgjesse): Use a MTU value here. Only the loopback adapter can
   // handle 64k datagrams.
   IsolateData* isolate_data =
       reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
   if (isolate_data->udp_receive_buffer == NULL) {
     isolate_data->udp_receive_buffer =
@@ skipping 50 matching lines @@
   // 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, dart_args);
   Dart_SetReturnValue(args, result);
 }
 
-
 void FUNCTION_NAME(Socket_WriteList)(Dart_NativeArguments args) {
   Socket* 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_write) {
     if (length > 1) {
@@ skipping 23 matching lines @@
       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);
     Dart_SetReturnValue(args, DartUtils::NewDartOSError(&os_error));
   }
 }
 
-
 void FUNCTION_NAME(Socket_SendTo)(Dart_NativeArguments args) {
   Socket* socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   Dart_Handle buffer_obj = Dart_GetNativeArgument(args, 1);
   intptr_t offset = DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 2));
   intptr_t length = DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 3));
   Dart_Handle address_obj = Dart_GetNativeArgument(args, 4);
   ASSERT(Dart_IsList(address_obj));
   RawAddr addr;
   SocketAddress::GetSockAddr(address_obj, &addr);
@@ skipping 16 matching lines @@
     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);
     Dart_SetReturnValue(args, DartUtils::NewDartOSError(&os_error));
   }
 }
 
-
 void FUNCTION_NAME(Socket_GetPort)(Dart_NativeArguments args) {
   Socket* socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   OSError os_error;
   intptr_t port = SocketBase::GetPort(socket->fd());
   if (port > 0) {
     Dart_SetReturnValue(args, Dart_NewInteger(port));
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
 }
 
-
 void FUNCTION_NAME(Socket_GetRemotePeer)(Dart_NativeArguments args) {
   Socket* socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   OSError os_error;
   intptr_t port = 0;
   SocketAddress* addr = SocketBase::GetRemotePeer(socket->fd(), &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();
     Dart_ListSetAt(entry, 2, SocketAddress::ToTypedData(raw));
 
     Dart_ListSetAt(list, 0, entry);
     Dart_ListSetAt(list, 1, Dart_NewInteger(port));
     Dart_SetReturnValue(args, list);
     delete addr;
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
 }
 
-
 void FUNCTION_NAME(Socket_GetError)(Dart_NativeArguments args) {
   Socket* socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   OSError os_error;
   SocketBase::GetError(socket->fd(), &os_error);
   Dart_SetReturnValue(args, DartUtils::NewDartOSError(&os_error));
 }
 
-
 void FUNCTION_NAME(Socket_GetType)(Dart_NativeArguments args) {
   Socket* socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   OSError os_error;
   intptr_t type = SocketBase::GetType(socket->fd());
   if (type >= 0) {
     Dart_SetReturnValue(args, Dart_NewInteger(type));
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
 }
 
-
 void FUNCTION_NAME(Socket_GetStdioHandle)(Dart_NativeArguments args) {
   int64_t num =
       DartUtils::GetInt64ValueCheckRange(Dart_GetNativeArgument(args, 1), 0, 2);
   intptr_t socket = SocketBase::GetStdioHandle(num);
   Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 0), socket,
                                  Socket::kFinalizerStdio);
   Dart_SetReturnValue(args, Dart_NewBoolean(socket >= 0));
 }
 
-
 void FUNCTION_NAME(Socket_GetSocketId)(Dart_NativeArguments args) {
   Socket* socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   intptr_t id = reinterpret_cast<intptr_t>(socket);
   Dart_SetReturnValue(args, Dart_NewInteger(id));
 }
 
-
 void FUNCTION_NAME(Socket_SetSocketId)(Dart_NativeArguments args) {
   intptr_t id = DartUtils::GetIntptrValue(Dart_GetNativeArgument(args, 1));
   Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 0), id,
                                  Socket::kFinalizerNormal);
 }
 
-
 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, backlog, v6_only, shared);
   Dart_SetReturnValue(args, result);
 }
 
-
 void FUNCTION_NAME(ServerSocket_Accept)(Dart_NativeArguments args) {
   Socket* socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   intptr_t new_socket = ServerSocket::Accept(socket->fd());
   if (new_socket >= 0) {
     Socket::SetSocketIdNativeField(Dart_GetNativeArgument(args, 1), new_socket,
                                    Socket::kFinalizerNormal);
     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) && request[0]->IsString() &&
       request[1]->IsInt32()) {
     CObjectString host(request[0]);
     CObjectInt32 type(request[1]);
     CObject* result = NULL;
     OSError* os_error = NULL;
     AddressList<SocketAddress>* addresses =
         SocketBase::LookupAddress(host.CString(), type.Value(), &os_error);
     if (addresses != NULL) {
@@ skipping 22 matching lines @@
       delete addresses;
     } else {
       result = CObject::NewOSError(os_error);
       delete os_error;
     }
     return result;
   }
   return CObject::IllegalArgumentError();
 }
 
-
 CObject* Socket::ReverseLookupRequest(const CObjectArray& request) {
   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 11 matching lines @@
       return new CObjectString(CObject::NewString(host));
     } else {
       CObject* result = CObject::NewOSError(os_error);
       delete os_error;
       return result;
     }
   }
   return CObject::IllegalArgumentError();
 }
 
-
 CObject* Socket::ListInterfacesRequest(const CObjectArray& request) {
   if ((request.Length() == 1) && request[0]->IsInt32()) {
     CObjectInt32 type(request[0]);
     CObject* result = NULL;
     OSError* os_error = NULL;
     AddressList<InterfaceSocketAddress>* addresses =
         SocketBase::ListInterfaces(type.Value(), &os_error);
     if (addresses != NULL) {
       CObjectArray* array =
           new CObjectArray(CObject::NewArray(addresses->count() + 1));
@@ skipping 29 matching lines @@
       delete addresses;
     } else {
       result = CObject::NewOSError(os_error);
       delete os_error;
     }
     return result;
   }
   return CObject::IllegalArgumentError();
 }
 
-
 void FUNCTION_NAME(Socket_GetOption)(Dart_NativeArguments args) {
   Socket* socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   int64_t option = DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 1));
   intptr_t protocol = static_cast<intptr_t>(
       DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 2)));
   bool ok = false;
   switch (option) {
     case 0: {  // TCP_NODELAY.
       bool enabled;
@@ skipping 34 matching lines @@
     default:
       UNREACHABLE();
       break;
   }
   // In case of failure the return value is not set above.
   if (!ok) {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
 }
 
-
 void FUNCTION_NAME(Socket_SetOption)(Dart_NativeArguments args) {
   bool result = false;
   Socket* socket =
       Socket::GetSocketIdNativeField(Dart_GetNativeArgument(args, 0));
   int64_t option = DartUtils::GetIntegerValue(Dart_GetNativeArgument(args, 1));
   int64_t protocol = DartUtils::GetInt64ValueCheckRange(
       Dart_GetNativeArgument(args, 2), SocketAddress::TYPE_IPV4,
       SocketAddress::TYPE_IPV6);
   switch (option) {
     case 0:  // TCP_NODELAY.
@@ skipping 24 matching lines @@
       Dart_PropagateError(Dart_NewApiError("Value outside expected range"));
       break;
   }
   if (result) {
     Dart_SetReturnValue(args, Dart_Null());
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
 }
 
-
 void FUNCTION_NAME(Socket_JoinMulticast)(Dart_NativeArguments args) {
   Socket* 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 (SocketBase::JoinMulticast(socket->fd(), addr, interface,
                                 interfaceIndex)) {
     Dart_SetReturnValue(args, Dart_Null());
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
 }
 
-
 void FUNCTION_NAME(Socket_LeaveMulticast)(Dart_NativeArguments args) {
   Socket* 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 (SocketBase::LeaveMulticast(socket->fd(), addr, interface,
                                  interfaceIndex)) {
     Dart_SetReturnValue(args, Dart_Null());
   } else {
     Dart_SetReturnValue(args, DartUtils::NewDartOSError());
   }
 }
 
-
 static void NormalSocketFinalizer(void* isolate_data,
                                   Dart_WeakPersistentHandle handle,
                                   void* data) {
   Socket* socket = reinterpret_cast<Socket*>(data);
   if (socket->fd() >= 0) {
     const int64_t flags = 1 << kCloseCommand;
     socket->Retain();
     EventHandler::SendFromNative(reinterpret_cast<intptr_t>(socket),
                                  socket->port(), flags);
   }
   socket->Release();
 }
 
-
 static void ListeningSocketFinalizer(void* isolate_data,
                                      Dart_WeakPersistentHandle handle,
                                      void* data) {
   Socket* socket = reinterpret_cast<Socket*>(data);
   if (socket->fd() >= 0) {
     const int64_t flags = (1 << kListeningSocket) | (1 << kCloseCommand);
     socket->Retain();
     EventHandler::SendFromNative(reinterpret_cast<intptr_t>(socket),
                                  socket->port(), flags);
   }
   socket->Release();
 }
 
-
 static void StdioSocketFinalizer(void* isolate_data,
                                  Dart_WeakPersistentHandle handle,
                                  void* data) {
   Socket* socket = reinterpret_cast<Socket*>(data);
   if (socket->fd() >= 0) {
     socket->SetClosedFd();
   }
   socket->Release();
 }
 
-
 void Socket::ReuseSocketIdNativeField(Dart_Handle handle,
                                       Socket* socket,
                                       SocketFinalizer finalizer) {
   Dart_Handle err = Dart_SetNativeInstanceField(
       handle, kSocketIdNativeField, reinterpret_cast<intptr_t>(socket));
   if (Dart_IsError(err)) {
     Dart_PropagateError(err);
   }
   Dart_WeakPersistentHandleFinalizer callback;
   switch (finalizer) {
@@ skipping 10 matching lines @@
       callback = NULL;
       UNREACHABLE();
       break;
   }
   if (callback != NULL) {
     Dart_NewWeakPersistentHandle(handle, reinterpret_cast<void*>(socket),
                                  sizeof(Socket), callback);
   }
 }
 
-
 void Socket::SetSocketIdNativeField(Dart_Handle handle,
                                     intptr_t id,
                                     SocketFinalizer finalizer) {
   Socket* socket = new Socket(id);
   ReuseSocketIdNativeField(handle, socket, finalizer);
 }
 
-
 Socket* Socket::GetSocketIdNativeField(Dart_Handle socket_obj) {
   intptr_t id;
   Dart_Handle err =
       Dart_GetNativeInstanceField(socket_obj, kSocketIdNativeField, &id);
   if (Dart_IsError(err)) {
     Dart_PropagateError(err);
   }
   Socket* socket = reinterpret_cast<Socket*>(id);
   return socket;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // !defined(DART_IO_DISABLED)