Dart: Refactor Stubs

mojo/dart/packages/mojo/lib/src/proxy.dart

 // Copyright 2014 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.
 
 part of bindings;
 
 /// The object that [ProxyMessageHandler.errorFuture] completes with when there
 /// is an error.
 class ProxyError {
   final String message;
@@ skipping 26 matching lines @@
 
   /// This is a convenience method that simply forwards to
   /// ctrl.responseOrError(). If a Mojo interface has a method
   /// 'responseOrError', its name will be mangled to be 'responseOrError_'.
   Future responseOrError(Future f) => ctrl.responseOrError(f);
 }
 
 /// Generated Proxy classes have a factory Proxy.connectToService which takes
 /// a ServiceConnector, a url, and optionally a service name and returns a
 /// bound Proxy. For example, every class extending the Application base class
-/// in package:mojo/application.dart inherits and implementation of the
+/// in package:mojo/application.dart inherits an implementation of the
 /// ServiceConnector interface.
 abstract class ServiceConnector {
   /// Connects [proxy] to the service called [serviceName] that lives at [url].
   void connectToService(String url, Proxy proxy, [String serviceName]);
 }
 
-class ProxyMessageHandler extends core.MojoEventHandler {
+abstract class ProxyMessageHandler extends core.MojoEventHandler {
   HashMap<int, Completer> _completerMap = new HashMap<int, Completer>();
   Completer _errorCompleter = new Completer();
   Set<Completer> _errorCompleters;
   int _nextId = 0;
   int _version = 0;
   int _pendingCount = 0;
 
   ProxyMessageHandler.fromEndpoint(core.MojoMessagePipeEndpoint endpoint)
       : super.fromEndpoint(endpoint);
 
   ProxyMessageHandler.fromHandle(core.MojoHandle handle)
       : super.fromHandle(handle);
 
   ProxyMessageHandler.unbound() : super.unbound();
 
   /// The function that handles responses to sent proxy message. It should be
   /// implemented by the generated ProxyControl classes that extend
   /// [ProxyMessageHandler].
-  void handleResponse(ServiceMessage msg) {}
+  void handleResponse(ServiceMessage msg);
 
   /// If there is an error in using this proxy, this future completes with
   /// a ProxyError.
   Future get errorFuture => _errorCompleter.future;
 
   /// Version of this interface that the remote side supports. Updated when a
   /// call to [queryVersion] or [requireVersion] is made.
   int get version => _version;
 
   /// Returns a service description, which exposes the mojom type information
@@ skipping 82 matching lines @@
       _pendingCount++;
     } else {
       proxyError("Write to message pipe endpoint failed: ${endpoint}");
     }
     return completer.future;
   }
 
   // Need a getter for this for access in subclasses.
   HashMap<int, Completer> get completerMap => _completerMap;
 
+  @override
   String toString() {
     var superString = super.toString();
     return "ProxyMessageHandler(${superString})";
   }
 
   /// Queries the max version that the remote side supports.
   /// Updates [version].
   Future<int> queryVersion() async {
     var params = new icm.RunMessageParams();
     params.reserved0 = 16;
@@ skipping 95 matching lines @@
       return;
     }
     completerMap.remove(message.header.requestId);
     if (c.isCompleted) {
       proxyError("Control message response completer already completed");
       return;
     }
     c.complete(response);
   }
 }