add optional request field to record time at which client made request

pkg/analysis_server/lib/src/protocol.dart

 // Copyright (c) 2014, 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.
 
 library protocol;
 
 import 'dart:collection';
 import 'dart:convert';
 
 part 'generated_protocol.dart';
@@ skipping 479 matching lines @@
    * The name of the JSON attribute containing the name of the request.
    */
   static const String METHOD = 'method';
 
   /**
    * The name of the JSON attribute containing the request parameters.
    */
   static const String PARAMS = 'params';
 
   /**
+   * The name of the optional JSON attribute indicating the time
+   * (milliseconds since epoch) at which the client made the request.
+   */
+  static const String CLIENT_REQUEST_TIME = 'clientRequestTime';
+
+  /**
    * The unique identifier used to identify this request.
    */
   final String id;
 
   /**
    * The method being requested.
    */
   final String method;
 
   /**
    * A table mapping the names of request parameters to their values.
    */
   final Map<String, Object> _params;
 
   /**
+   * The time (milliseconds since epoch) at which the client made the request
+   * or `null` if this information is not provided by the client.
+   */
+  final int clientRequestTime;
+
+  /**
    * Initialize a newly created [Request] to have the given [id] and [method]
    * name.  If [params] is supplied, it is used as the "params" map for the
    * request.  Otherwise an empty "params" map is allocated.
    */
-  Request(this.id, this.method, [Map<String, Object> params])
+  Request(this.id, this.method, [Map<String, Object> params,
+      this.clientRequestTime])
       : _params = params != null ? params : new HashMap<String, Object>();
 
   /**
    * Return a request parsed from the given [data], or `null` if the [data] is
    * not a valid json representation of a request. The [data] is expected to
    * have the following format:
    *
    *   {
    *     'id': String,
    *     'method': methodName,
    *     'params': {
    *       paramter_name: value
    *     }
+   *     'clientRequestTime': millisecondsSinceEpoch
    *   }
    *
-   * where the parameters are optional and can contain any number of name/value
-   * pairs.
+   * where both the parameters and clientRequestTime are optional.
+   * The parameters can contain any number of name/value pairs.
+   * The clientRequestTime must be an int representing the time at which
+   * the client issued the request (milliseconds since epoch).
    */
   factory Request.fromString(String data) {
     try {
       var result = JSON.decode(data);
       if (result is! Map) {
         return null;
       }
       var id = result[Request.ID];
       var method = result[Request.METHOD];
       if (id is! String || method is! String) {
         return null;
       }
+      var time = result[Request.CLIENT_REQUEST_TIME];
+      if (time != null && time is! int) {
+        return null;
+      }
       var params = result[Request.PARAMS];
       if (params is Map || params == null) {
-        return new Request(id, method, params);
+        return new Request(id, method, params, time);
       } else {
         return null;
       }
     } catch (exception) {
       return null;
     }
   }
 
   /**
    * Return a table representing the structure of the Json object that will be
    * sent to the client to represent this response.
    */
   Map<String, Object> toJson() {
     Map<String, Object> jsonObject = new HashMap<String, Object>();
     jsonObject[ID] = id;
     jsonObject[METHOD] = method;
     if (_params.isNotEmpty) {
       jsonObject[PARAMS] = _params;
     }
+    if (clientRequestTime != null) {
+      jsonObject[CLIENT_REQUEST_TIME] = clientRequestTime;
+    }
     return jsonObject;
   }
 }
 
 
 /**
  * JsonDecoder for decoding requests.  Errors are reporting by throwing a
  * [RequestFailure].
  */
 class RequestDecoder extends JsonDecoder {
@@ skipping 103 matching lines @@
   /**
    * Initialize a newly created instance to represent a response to a request
    * with the given [id].  If [_result] is provided, it will be used as the
    * result; otherwise an empty result will be used.  If an [error] is provided
    * then the response will represent an error condition.
    */
   Response(this.id, {Map<String, Object> result, this.error})
       : _result = result;
 
   /**
+   * Initialize a newly created instance to represent the
+   * FORMAT_INVALID_FILE error condition.
+   */
+  Response.formatInvalidFile(Request request)
+      : this(
+          request.id,
+          error: new RequestError(
+              RequestErrorCode.FORMAT_INVALID_FILE,
+              'Error during `edit.format`: invalid file.'));
+
+  /**
    * Initialize a newly created instance based upon the given JSON data
    */
   factory Response.fromJson(Map<String, Object> json) {
     try {
       Object id = json[Response.ID];
       if (id is! String) {
         return null;
       }
       Object error = json[Response.ERROR];
       RequestError decodedError;
       if (error is Map) {
         decodedError =
             new RequestError.fromJson(new ResponseDecoder(null), '.error', error);
       }
       Object result = json[Response.RESULT];
       Map<String, Object> decodedResult;
       if (result is Map) {
         decodedResult = result;
       }
       return new Response(id, error: decodedError, result: decodedResult);
     } catch (exception) {
       return null;
     }
   }
 
   /**
    * Initialize a newly created instance to represent the
-   * FORMAT_INVALID_FILE error condition.
-   */
-  Response.formatInvalidFile(Request request)
-      : this(
-          request.id,
-          error: new RequestError(
-              RequestErrorCode.FORMAT_INVALID_FILE,
-              'Error during `edit.format`: invalid file.'));
-
-  /**
-   * Initialize a newly created instance to represent the
    * GET_ERRORS_INVALID_FILE error condition.
    */
   Response.getErrorsInvalidFile(Request request)
       : this(
           request.id,
           error: new RequestError(
               RequestErrorCode.GET_ERRORS_INVALID_FILE,
               'Error during `analysis.getErrors`: invalid file.'));
 
   /**
@@ skipping 134 matching lines @@
     hash = 0x1fffffff & (hash + ((0x03ffffff & hash) << 3));
     hash = hash ^ (hash >> 11);
     return 0x1fffffff & (hash + ((0x00003fff & hash) << 15));
   }
 
   static int hash2(a, b) => finish(combine(combine(0, a), b));
 
   static int hash4(a, b, c, d) =>
       finish(combine(combine(combine(combine(0, a), b), c), d));
 }