Cleanup in //runtime/bin

runtime/bin/eventhandler.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_H_
 #define BIN_EVENTHANDLER_H_
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/isolate_data.h"
@@ skipping 90 matching lines @@
 
   void RemoveCurrent() {
     UpdateTimeout(CurrentPort(), -1);
   }
 
   void UpdateTimeout(Dart_Port port, int64_t timeout);
 
  private:
   Timeout* next_timeout_;
   Timeout* timeouts_;
+
+  DISALLOW_COPY_AND_ASSIGN(TimeoutQueue);
 };
 
 
 class InterruptMessage {
  public:
   intptr_t id;
   Dart_Port dart_port;
   int64_t data;
 };
 
@@ skipping 93 matching lines @@
 
  private:
   struct Entry {
     explicit Entry(const T& t) : t(t), next_(NULL), prev_(NULL) {}
     const T t;
     Entry* next_;
     Entry* prev_;
   };
 
   Entry* head_;
+
+  DISALLOW_COPY_AND_ASSIGN(CircularLinkedList);
 };
 
 
 class DescriptorInfoBase {
  public:
   explicit DescriptorInfoBase(intptr_t fd) : fd_(fd) {
     ASSERT(fd_ != -1);
   }
 
   virtual ~DescriptorInfoBase() {}
@@ skipping 27 matching lines @@
 
   // Returns the union of event masks of all ports. If a port has a non-positive
   // token count it's mask is assumed to be 0.
   virtual intptr_t Mask() = 0;
 
   // Closes this descriptor.
   virtual void Close() = 0;
 
  protected:
   intptr_t fd_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DescriptorInfoBase);
 };
 
 
 // Describes a OS descriptor (e.g. file descriptor on linux or HANDLE on
 // windows) which is connected to a single Dart_Port.
 //
 // Subclasses of this class can be e.g. connected tcp sockets.
 template<typename DI>
 class DescriptorInfoSingleMixin : public DI {
  private:
   static const int kTokenCount = 16;
 
  public:
-  explicit DescriptorInfoSingleMixin(intptr_t fd, bool disable_tokens)
+  DescriptorInfoSingleMixin(intptr_t fd, bool disable_tokens)
       : DI(fd), port_(0), tokens_(kTokenCount), mask_(0),
         disable_tokens_(disable_tokens) {}
 
   virtual ~DescriptorInfoSingleMixin() { }
 
   virtual bool IsListeningSocket() const { return false; }
 
   virtual void SetPortAndMask(Dart_Port port, intptr_t mask) {
     ASSERT(port_ == 0 || port == port_);
     port_ = port;
@@ skipping 54 matching lines @@
 
   virtual void Close() {
     DI::Close();
   }
 
  private:
   Dart_Port port_;
   int tokens_;
   intptr_t mask_;
   bool disable_tokens_;
+
+  DISALLOW_COPY_AND_ASSIGN(DescriptorInfoSingleMixin);
 };
 
 
 // Describes a OS descriptor (e.g. file descriptor on linux or HANDLE on
 // windows) which is connected to multiple Dart_Port's.
 //
 // Subclasses of this class can be e.g. a listening socket which multiple
 // isolates are listening on.
 template<typename DI>
 class DescriptorInfoMultipleMixin : public DI {
@@ skipping 24 matching lines @@
 
   struct PortEntry {
     Dart_Port dart_port;
     intptr_t is_reading;
     intptr_t token_count;
 
     bool IsReady() { return token_count > 0 && is_reading; }
   };
 
  public:
-  explicit DescriptorInfoMultipleMixin(intptr_t fd, bool disable_tokens)
+  DescriptorInfoMultipleMixin(intptr_t fd, bool disable_tokens)
       : DI(fd), tokens_map_(&SamePortValue, kTokenCount),
         disable_tokens_(disable_tokens) {}
 
   virtual ~DescriptorInfoMultipleMixin() {}
 
   virtual bool IsListeningSocket() const { return true; }
 
   virtual void SetPortAndMask(Dart_Port port, intptr_t mask) {
     HashMap::Entry* entry = tokens_map_.Lookup(
         GetHashmapKeyFromPort(port), GetHashmapHashFromPort(port), true);
@@ skipping 120 matching lines @@
          entry = tokens_map_.Next(entry)) {
       PortEntry* pentry = reinterpret_cast<PortEntry*>(entry->value);
       DartUtils::PostInt32(pentry->dart_port, events);
 
       // Update token count.
       bool was_ready = pentry->IsReady();
       if (!disable_tokens_) {
         pentry->token_count--;
       }
 
-      if (was_ready && pentry->token_count <= 0) {
+      if (was_ready && (pentry->token_count <= 0)) {
         active_readers_.Remove(pentry);
       }
     }
   }
 
   virtual void ReturnTokens(Dart_Port port, int count) {
     HashMap::Entry* entry = tokens_map_.Lookup(
         GetHashmapKeyFromPort(port), GetHashmapHashFromPort(port), false);
     ASSERT(entry != NULL);
 
@@ skipping 24 matching lines @@
   // The [Dart_Port]s which are not paused (i.e. are interested in read events,
   // i.e. `mask == (1 << kInEvent)`) and we have enough tokens to communicate
   // with them.
   CircularLinkedList<PortEntry *> active_readers_;
 
   // A convenience mapping:
   //   Dart_Port -> struct PortEntry { dart_port, mask, token_count }
   HashMap tokens_map_;
 
   bool disable_tokens_;
+
+  DISALLOW_COPY_AND_ASSIGN(DescriptorInfoMultipleMixin);
 };
 
-
 }  // namespace bin
 }  // namespace dart
 
 // The event handler delegation class is OS specific.
 #if defined(TARGET_OS_ANDROID)
 #include "bin/eventhandler_android.h"
 #elif defined(TARGET_OS_LINUX)
 #include "bin/eventhandler_linux.h"
 #elif defined(TARGET_OS_MACOS)
 #include "bin/eventhandler_macos.h"
 #elif defined(TARGET_OS_WINDOWS)
 #include "bin/eventhandler_win.h"
 #else
 #error Unknown target os.
 #endif
 
 namespace dart {
 namespace bin {
 
 class EventHandler {
  public:
+  EventHandler() {}
   void SendData(intptr_t id, Dart_Port dart_port, int64_t data) {
     delegate_.SendData(id, dart_port, data);
   }
 
   /**
    * Signal to main thread that event handler is done.
    */
   void NotifyShutdownDone();
 
   /**
    * Start the event-handler.
    */
   static void Start();
 
   /**
    * Stop the event-handler. It's expected that there will be no further calls
    * to SendData after a call to Stop.
    */
   static void Stop();
 
   static EventHandlerImplementation* delegate();
 
  private:
   friend class EventHandlerImplementation;
   EventHandlerImplementation delegate_;
+
+  DISALLOW_COPY_AND_ASSIGN(EventHandler);
 };
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // BIN_EVENTHANDLER_H_