Refactor the io resource classes

runtime/bin/socket_patch.dart

 // 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.
 
 patch class RawServerSocket {
   /* patch */ static Future<RawServerSocket> bind(address,
                                                   int port,
                                                   {int backlog: 0,
                                                    bool v6Only: false,
                                                    bool shared: false}) {
@@ skipping 295 matching lines @@
 
   int tokens = 0;
 
   bool sendReadEvents = false;
   bool readEventIssued = false;
 
   bool sendWriteEvents = false;
   bool writeEventIssued = false;
   bool writeAvailable = false;
 
-  static final Stopwatch sw = new Stopwatch()..start();
-
   static bool connectedResourceHandler = false;
   _ReadWriteResourceInfo resourceInfo;
 
   // The owner object is the object that the Socket is being used by, e.g.
   // a HttpServer, a WebSocket connection, a process pipe, etc.
   Object owner;
 
   static double get timestamp => sw.elapsedMicroseconds / 1000000.0;
 
   static Future<List<InternetAddress>> lookup(
@@ skipping 249 matching lines @@
       available -= result.length;
       // TODO(ricow): Remove when we track internal and pipe uses.
       assert(resourceInfo != null || isPipe || isInternal);
       if (resourceInfo != null) {
         resourceInfo.totalRead += result.length;
       }
     }
     // TODO(ricow): Remove when we track internal and pipe uses.
     assert(resourceInfo != null || isPipe || isInternal);
     if (resourceInfo != null) {
-      resourceInfo.readCount++;
-      resourceInfo.lastRead = timestamp;
+      resourceInfo.didRead();
     }
     return result;
   }
 
   Datagram receive() {
     if (isClosing || isClosed) return null;
     var result = nativeRecvFrom();
     if (result is OSError) {
       reportError(result, "Receive failed");
       return null;
     }
     if (result != null) {
       // Read the next available. Available is only for the next datagram, not
       // the sum of all datagrams pending, so we need to call after each
       // receive. If available becomes > 0, the _NativeSocket will continue to
       // emit read events.
       available = nativeAvailable();
       // TODO(ricow): Remove when we track internal and pipe uses.
       assert(resourceInfo != null || isPipe || isInternal);
       if (resourceInfo != null) {
         resourceInfo.totalRead += result.data.length;
       }
     }
     // TODO(ricow): Remove when we track internal and pipe uses.
     assert(resourceInfo != null || isPipe || isInternal);
     if (resourceInfo != null) {
-      resourceInfo.readCount++;
-      resourceInfo.lastRead = timestamp;
+      resourceInfo.didRead();
     }
     return result;
   }
 
   int write(List<int> buffer, int offset, int bytes) {
     if (buffer is! List) throw new ArgumentError();
     if (offset == null) offset = 0;
     if (bytes == null) {
       if (offset > buffer.length) {
         throw new RangeError.value(offset);
@@ skipping 22 matching lines @@
     // purpose. In such case, don't mark writeAvailable as false, as we don't
     // know if we'll receive an event. It's better to just retry.
     if (result >= 0 && result < bytes) {
       writeAvailable = false;
     }
     // Negate the result, as stated above.
     if (result < 0) result = -result;
     // TODO(ricow): Remove when we track internal and pipe uses.
     assert(resourceInfo != null || isPipe || isInternal);
     if (resourceInfo != null) {
-      resourceInfo.totalWritten += result;
-      resourceInfo.writeCount++;
-      resourceInfo.lastWrite = timestamp;
+      resourceInfo.addWrite(result);
     }
     return result;
   }
 
   int send(List<int> buffer, int offset, int bytes,
            InternetAddress address, int port) {
     if (isClosing || isClosed) return 0;
     _BufferAndStart bufferAndStart =
         _ensureFastAndSerializableByteData(
             buffer, offset, bytes);
     var result = nativeSendTo(
         bufferAndStart.buffer, bufferAndStart.start, bytes,
         address._in_addr, port);
     if (result is OSError) {
       scheduleMicrotask(() => reportError(result, "Send failed"));
       result = 0;
     }
     // TODO(ricow): Remove when we track internal and pipe uses.
     assert(resourceInfo != null || isPipe || isInternal);
     if (resourceInfo != null) {
-      resourceInfo.totalWritten += result;
-      resourceInfo.writeCount++;
-      resourceInfo.lastWrite = timestamp;
+      resourceInfo.addWrite(result);
     }
     return result;
   }
 
   _NativeSocket accept() {
     // Don't issue accept if we're closing.
     if (isClosing || isClosed) return null;
     assert(available > 0);
     available--;
     tokens++;
     returnTokens(LISTENING_TOKEN_BATCH_SIZE);
     var socket = new _NativeSocket.normal();
     if (nativeAccept(socket) != true) return null;
     socket.localPort = localPort;
     socket.localAddress = address;
     setupResourceInfo(socket);
     // TODO(ricow): Remove when we track internal and pipe uses.
     assert(resourceInfo != null || isPipe || isInternal);
     if (resourceInfo != null) {
-      resourceInfo.totalRead += 1;
-      resourceInfo.lastRead = timestamp;
+      // We track this as read one byte.
+      resourceInfo.addRead(1);
     }
     return socket;
   }
 
   int get port {
     if (localPort != 0) return localPort;
     if (isClosing || isClosed) throw const SocketException.closed();
     var result = nativeGetPort();
     if (result is OSError) throw result;
     return localPort = result;
@@ skipping 1193 matching lines @@
 Datagram _makeDatagram(List<int> data,
                        String address,
                        List<int> in_addr,
                        int port) {
   return new Datagram(
       data,
       new _InternetAddress(address, null, in_addr),
       port);
 }