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

runtime/bin/eventhandler_win.h

 // Copyright (c) 2012, 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_EVENTHANDLER_WIN_H_
 #define RUNTIME_BIN_EVENTHANDLER_WIN_H_
 
 #if !defined(RUNTIME_BIN_EVENTHANDLER_H_)
 #error Do not include eventhandler_win.h directly; use eventhandler.h instead.
 #endif
@@ skipping 273 matching lines @@
   void NotifyReadThreadStarted();
   void WaitForReadThreadFinished();
   void NotifyReadThreadFinished();
 
   int flags_;
 
   friend class ReferenceCounted<Handle>;
   DISALLOW_COPY_AND_ASSIGN(Handle);
 };
 
-
 class FileHandle : public DescriptorInfoSingleMixin<Handle> {
  public:
   explicit FileHandle(HANDLE handle)
       : DescriptorInfoSingleMixin(reinterpret_cast<intptr_t>(handle), true) {
     type_ = kFile;
   }
 
   virtual void EnsureInitialized(EventHandlerImplementation* event_handler);
   virtual bool IsClosed();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FileHandle);
 };
 
-
 class StdHandle : public FileHandle {
  public:
   static StdHandle* Stdin(HANDLE handle);
 
   virtual void DoClose();
   virtual intptr_t Write(const void* buffer, intptr_t num_bytes);
 
   void WriteSyncCompleteAsync();
   void RunWriteLoop();
 
@@ skipping 17 matching lines @@
 
   ThreadId thread_id_;
   HANDLE thread_handle_;
   intptr_t thread_wrote_;
   bool write_thread_exists_;
   bool write_thread_running_;
 
   DISALLOW_COPY_AND_ASSIGN(StdHandle);
 };
 
-
 class DirectoryWatchHandle : public DescriptorInfoSingleMixin<Handle> {
  public:
   DirectoryWatchHandle(HANDLE handle, int events, bool recursive)
       : DescriptorInfoSingleMixin(reinterpret_cast<intptr_t>(handle), true),
         events_(events),
         recursive_(recursive) {
     type_ = kDirectoryWatch;
   }
 
   virtual void EnsureInitialized(EventHandlerImplementation* event_handler);
   virtual bool IsClosed();
 
   virtual bool IssueRead();
 
   void Stop();
 
  private:
   int events_;
   bool recursive_;
 
   DISALLOW_COPY_AND_ASSIGN(DirectoryWatchHandle);
 };
 
-
 class SocketHandle : public Handle {
  public:
   SOCKET socket() const { return socket_; }
 
  protected:
   explicit SocketHandle(intptr_t s) : Handle(s), socket_(s) {}
 
   virtual void HandleIssueError();
 
  private:
   const SOCKET socket_;
 
   DISALLOW_COPY_AND_ASSIGN(SocketHandle);
 };
 
-
 // Information on listen sockets.
 class ListenSocket : public DescriptorInfoMultipleMixin<SocketHandle> {
  public:
   explicit ListenSocket(intptr_t s)
       : DescriptorInfoMultipleMixin(s, true),
         AcceptEx_(NULL),
         pending_accept_count_(0),
         accepted_head_(NULL),
         accepted_tail_(NULL),
         accepted_count_(0) {
@@ skipping 36 matching lines @@
   ClientSocket* accepted_head_;
   ClientSocket* accepted_tail_;
 
   // The number of accepted connections which are waiting to be removed from
   // this queue and processed by dart isolates.
   int accepted_count_;
 
   DISALLOW_COPY_AND_ASSIGN(ListenSocket);
 };
 
-
 // Information on connected sockets.
 class ClientSocket : public DescriptorInfoSingleMixin<SocketHandle> {
  public:
   explicit ClientSocket(intptr_t s)
       : DescriptorInfoSingleMixin(s, true),
         DisconnectEx_(NULL),
         next_(NULL),
         connected_(false),
         closed_(false) {
     LoadDisconnectEx();
@@ skipping 42 matching lines @@
   bool connected_;
   bool closed_;
 
 #if defined(DEBUG)
   static intptr_t disconnecting_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(ClientSocket);
 };
 
-
 class DatagramSocket : public DescriptorInfoSingleMixin<SocketHandle> {
  public:
   explicit DatagramSocket(intptr_t s) : DescriptorInfoSingleMixin(s, true) {
     type_ = kDatagramSocket;
   }
 
   virtual ~DatagramSocket() {
     // Don't delete this object until all pending requests have been handled.
     ASSERT(!HasPendingRead());
     ASSERT(!HasPendingWrite());
   }
 
   // Internal interface used by the event handler.
   virtual bool IssueRecvFrom();
   virtual bool IssueSendTo(sockaddr* sa, socklen_t sa_len);
 
   virtual void EnsureInitialized(EventHandlerImplementation* event_handler);
   virtual void DoClose();
   virtual bool IsClosed();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DatagramSocket);
 };
 
-
 // Event handler.
 class EventHandlerImplementation {
  public:
   EventHandlerImplementation();
   virtual ~EventHandlerImplementation();
 
   void SendData(intptr_t id, Dart_Port dart_port, int64_t data);
   void Start(EventHandler* handler);
   void Shutdown();
 
@@ skipping 31 matching lines @@
   bool shutdown_;
   HANDLE completion_port_;
 
   DISALLOW_COPY_AND_ASSIGN(EventHandlerImplementation);
 };
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // RUNTIME_BIN_EVENTHANDLER_WIN_H_