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

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 RUNTIME_BIN_SOCKET_H_
 #define RUNTIME_BIN_SOCKET_H_
 
 #if defined(DART_IO_DISABLED)
 #error "socket.h can only be included on builds with IO enabled"
 #endif
@@ skipping 70 matching lines @@
 
   static const int kClosedFd = -1;
 
   intptr_t fd_;
   Dart_Port port_;
 
   friend class ReferenceCounted<Socket>;
   DISALLOW_COPY_AND_ASSIGN(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(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);
 };
 
-
 class ListeningSocketRegistry {
  public:
   ListeningSocketRegistry()
       : sockets_by_port_(SameIntptrValue, kInitialSocketsCount),
         sockets_by_fd_(SameIntptrValue, kInitialSocketsCount),
         mutex_(new Mutex()) {}
 
   ~ListeningSocketRegistry() {
     CloseAllSafe();
     delete mutex_;
@@ skipping 66 matching lines @@
   }
 
   static bool SameIntptrValue(void* key1, void* key2) {
     return reinterpret_cast<intptr_t>(key1) == reinterpret_cast<intptr_t>(key2);
   }
 
   static uint32_t GetHashmapHashFromIntptr(intptr_t i) {
     return static_cast<uint32_t>((i + 1) & 0xFFFFFFFF);
   }
 
-
   static void* GetHashmapKeyFromIntptr(intptr_t i) {
     return reinterpret_cast<void*>(i + 1);
   }
 
   OSSocket* LookupByPort(intptr_t port);
   void InsertByPort(intptr_t port, OSSocket* socket);
   void RemoveByPort(intptr_t port);
 
   OSSocket* LookupByFd(Socket* fd);
   void InsertByFd(Socket* fd, OSSocket* socket);
   void RemoveByFd(Socket* fd);
 
   bool CloseOneSafe(OSSocket* os_socket, bool update_hash_maps);
   void CloseAllSafe();
 
   HashMap sockets_by_port_;
   HashMap sockets_by_fd_;
 
   Mutex* mutex_;
 
   DISALLOW_COPY_AND_ASSIGN(ListeningSocketRegistry);
 };
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // RUNTIME_BIN_SOCKET_H_