Cleanup in //runtime/bin

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 BIN_EVENTHANDLER_WIN_H_
 #define BIN_EVENTHANDLER_WIN_H_
 
 #if !defined(BIN_EVENTHANDLER_H_)
 #error Do not include eventhandler_win.h directly; use eventhandler.h instead.
 #endif
 
+#include <mswsock.h>
 #include <winsock2.h>
 #include <ws2tcpip.h>
-#include <mswsock.h>
 
 #include "bin/builtin.h"
 #include "bin/thread.h"
 
-
 namespace dart {
 namespace bin {
 
 // Forward declarations.
 class EventHandlerImplementation;
 class Handle;
 class FileHandle;
 class SocketHandle;
 class ClientSocket;
 class ListenSocket;
 
-
 // An OverlappedBuffer encapsulates the OVERLAPPED structure and the
 // associated data buffer. For accept it also contains the pre-created
 // socket for the client.
 class OverlappedBuffer {
  public:
   enum Operation {
     kAccept, kRead, kRecvFrom, kWrite, kSendTo, kDisconnect, kConnect
   };
 
   static OverlappedBuffer* AllocateAcceptBuffer(int buffer_size);
@@ skipping 100 matching lines @@
 
   // For the recvfrom operation additional storace is allocated for the
   // source sockaddr.
   socklen_t* from_len_addr_;  // Pointer to source sockaddr size storage.
   struct sockaddr* from_;  // Pointer to source sockaddr storage.
 
   // Buffer for recv/send/AcceptEx. This must be at the end of the
   // object as the object is allocated larger than it's definition
   // indicate to extend this array.
   uint8_t buffer_data_[1];
+
+  DISALLOW_COPY_AND_ASSIGN(OverlappedBuffer);
 };
 
 
 // Abstract super class for holding information on listen and connected
 // sockets.
 class Handle : public DescriptorInfoBase {
  public:
   enum Type {
     kFile,
     kStd,
@@ skipping 104 matching lines @@
   bool read_thread_starting_;
   bool read_thread_finished_;
 
  private:
   void WaitForReadThreadStarted();
   void NotifyReadThreadStarted();
   void WaitForReadThreadFinished();
   void NotifyReadThreadFinished();
 
   int flags_;
+
+  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:
   explicit StdHandle(HANDLE handle)
       : FileHandle(handle),
         thread_id_(Thread::kInvalidThreadId),
         thread_wrote_(0),
         write_thread_exists_(false),
         write_thread_running_(false) {
     type_ = kStd;
   }
 
   virtual void DoClose();
   virtual intptr_t Write(const void* buffer, intptr_t num_bytes);
 
   void WriteSyncCompleteAsync();
   void RunWriteLoop();
 
  private:
   ThreadId thread_id_;
   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),
@@ skipping 35 matching lines @@
   int pending_accept_count_;
 
   // Linked list of accepted connections provided by completion code. Ready to
   // be handed over through accept.
   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),
@@ skipping 37 matching lines @@
     closed_ = true;
   }
 
  private:
   bool LoadDisconnectEx();
 
   LPFN_DISCONNECTEX DisconnectEx_;
   ClientSocket* next_;
   bool connected_;
   bool closed_;
+
+  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 19 matching lines @@
 
  private:
   ClientSocket* client_sockets_head_;
 
   Monitor* startup_monitor_;
   ThreadId handler_thread_id_;
 
   TimeoutQueue timeout_queue_;  // Time for next timeout.
   bool shutdown_;
   HANDLE completion_port_;
+
+  DISALLOW_COPY_AND_ASSIGN(EventHandlerImplementation);
 };
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // BIN_EVENTHANDLER_WIN_H_