Dart: Avoid MojoResult and MojoHandleSignals constructors.

mojo/dart/embedder/io/socket_patch.dart

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 //
 // Implementation of Socket and RawSocket for Mojo.
 //
 
 patch class Socket {
   /* patch */ static Future<Socket> connect(host, int port, {sourceAddress}) {
@@ skipping 227 matching lines @@
 
   bool setOption(SocketOption option, bool enabled) {
     // TODO(johnmccutchan): Implement.
     return false;
   }
 
   _onInputData(List<int> event) {
     if (_inClosed) {
       return;
     }
-    var signalsWatched = new MojoHandleSignals(event[0]);
-    var signalsReceived = new MojoHandleSignals(event[1]);
+    int signalsWatched = event[0];
+    int signalsReceived = event[1];
     if (_trace) {
       _tracePrint('<- IN: ${signalsReceived}');
     }
-    if (signalsReceived.isReadable) {
+    if (MojoHandleSignals.isReadable(signalsReceived)) {
       if (_trace) {
         _tracePrint('<- READ');
       }
       _controller.add(RawSocketEvent.READ);
     }
-    if (signalsReceived.isPeerClosed) {
+    if (MojoHandleSignals.isPeerClosed(signalsReceived)) {
       if (_trace) {
         _tracePrint('<- READ_CLOSED');
       }
       _controller.add(RawSocketEvent.READ_CLOSED);
       // Once we are closed, stop reporting events.
       _inClosed = true;
       return;
     }
   }
 
   _onOutputData(List<int> event) {
     if (_outClosed) {
       return;
     }
-    var signalsWatched = new MojoHandleSignals(event[0]);
-    var signalsReceived = new MojoHandleSignals(event[1]);
+    int signalsWatched = event[0];
+    int signalsReceived = event[1];
     if (_trace) {
       _tracePrint('<- OUT: ${signalsReceived}');
     }
-    if (signalsReceived.isPeerClosed) {
+    if (MojoHandleSignals.isPeerClosed(signalsReceived)) {
       if (_trace) {
         _tracePrint('<- CLOSED');
       }
       _controller.add(RawSocketEvent.CLOSED);
       // Once we are closed, stop reporting events.
       _outClosed = true;
       return;
     }
-    if (signalsReceived.isWritable) {
+    if (MojoHandleSignals.isWritable(signalsReceived)) {
       if (_trace) {
         _tracePrint('<- WRITE');
       }
       _controller.add(RawSocketEvent.WRITE);
     }
   }
 
   _setupIn() {
     assert(_pipeInEvents == null);
-    _pipeInEvents = new MojoEventSubscription(_pipeIn.consumer.handle,
-                                        MojoHandleSignals.READABLE +
-                                        MojoHandleSignals.PEER_CLOSED);
+    _pipeInEvents = new MojoEventSubscription(
+        _pipeIn.consumer.handle, MojoHandleSignals.kPeerClosedReadable);
     _pipeInEvents.subscribe(_onInputData);
   }
 
   _setupOut() {
     assert(_pipeOutEvents == null);
-    _pipeOutEvents = new MojoEventSubscription(_pipeOut.producer.handle,
-                                         MojoHandleSignals.WRITABLE +
-                                         MojoHandleSignals.PEER_CLOSED);
+    _pipeOutEvents = new MojoEventSubscription(
+        _pipeOut.producer.handle, MojoHandleSignals.kPeerClosedWritable);
     _pipeOutEvents.subscribe(_onOutputData);
   }
 
   _shutdownIn([bool force = false]) {
     _inClosed = true;
     if (_trace) {
       _tracePrint('shutdown IN');
       _tracePipeIn();
     }
     if (_pipeInEvents != null) {
@@ skipping 140 matching lines @@
                                              bool cancelOnError}) {
     return _controller.stream.listen(onData, onError: onError, onDone: onDone,
                                      cancelOnError: cancelOnError);
   }
 
 
   static _enableReadEvents(MojoEventSubscription subscription) {
     if (subscription == null) {
       return;
     }
-    subscription.enableSignals(MojoHandleSignals.PEER_CLOSED +
-                               MojoHandleSignals.READABLE);
+    subscription.enableSignals(MojoHandleSignals.kPeerClosedReadable);
   }
 
   static _enableWriteEvents(MojoEventSubscription subscription) {
     if (subscription == null) {
       return;
     }
-    subscription.enableSignals(MojoHandleSignals.PEER_CLOSED +
-                               MojoHandleSignals.WRITABLE);
+    subscription.enableSignals(MojoHandleSignals.kPeerClosedWritable);
   }
 
   static _disableEvents(MojoEventSubscription subscription) {
     if (subscription == null) {
       return;
     }
-    subscription.enableSignals(MojoHandleSignals.PEER_CLOSED);
+    subscription.enableSignals(MojoHandleSignals.kPeerClosed);
   }
 
   _pause() {
     _disableEvents(_pipeInEvents);
     _disableEvents(_pipeOutEvents);
   }
 
   void _resume() {
     if (_pipeInEvents != null) {
       if (_readEventsEnabled) {
@@ skipping 320 matching lines @@
       if (_raw != null) {
         _raw.shutdown(SocketDirection.SEND);
         _disableWriteEvent();
       }
     }
   }
 
   Map _toJSON(bool ref) => _raw._toJSON(ref);
   void set _owner(owner) { _raw._owner = owner; }
 }