Update date_time.

tool/input_sdk/patch/core_patch.dart

 // 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.
 
 // Patch file for dart:core classes.
 import "dart:_internal" as _symbol_dev;
 import 'dart:_interceptors';
 import 'dart:_js_helper' show patch,
                               checkInt,
                               getRuntimeType,
@@ skipping 133 matching lines @@
   }
 
   @patch
   StackTrace get stackTrace => Primitives.extractStackTrace(this);
 }
 
 // Patch for DateTime implementation.
 @patch
 class DateTime {
   @patch
+  DateTime.fromMillisecondsSinceEpoch(int millisecondsSinceEpoch,
+                                      {bool isUtc: false})
+      : this._withValue(millisecondsSinceEpoch, isUtc: isUtc);
+
+  @patch
+  DateTime.fromMicrosecondsSinceEpoch(int microsecondsSinceEpoch,
+                                      {bool isUtc: false})
+      : this._withValue(
+          _microsecondInRoundedMilliseconds(microsecondsSinceEpoch),
+          isUtc: isUtc);
+
+  @patch
   DateTime._internal(int year,
                      int month,
                      int day,
                      int hour,
                      int minute,
                      int second,
                      int millisecond,
+                     int microsecond,
                      bool isUtc)
         // checkBool is manually inlined here because dart2js doesn't inline it
         // and [isUtc] is usually a constant.
-      : this.isUtc = isUtc is bool ? isUtc : throw new ArgumentError(isUtc),
-        millisecondsSinceEpoch = checkInt(Primitives.valueFromDecomposedDate(
-            year, month, day, hour, minute, second, millisecond, isUtc));
+      : this.isUtc = isUtc is bool
+            ? isUtc
+            : throw new ArgumentError.value(isUtc, 'isUtc'),
+        _value = checkInt(Primitives.valueFromDecomposedDate(
+            year, month, day, hour, minute, second,
+            millisecond + _microsecondInRoundedMilliseconds(microsecond),
+            isUtc));
 
   @patch
   DateTime._now()
       : isUtc = false,
-        millisecondsSinceEpoch = Primitives.dateNow();
+        _value = Primitives.dateNow();
 
-  @patch
-  static int _brokenDownDateToMillisecondsSinceEpoch(
-      int year, int month, int day, int hour, int minute, int second,
-      int millisecond, bool isUtc) {
-    return Primitives.valueFromDecomposedDate(
-        year, month, day, hour, minute, second, millisecond, isUtc);
+  /// Rounds the given [microsecond] to the nearest milliseconds value.
+  ///
+  /// For example, invoked with argument `2600` returns `3`.
+  static int _microsecondInRoundedMilliseconds(int microsecond) {
+    return (microsecond / 1000).round();
   }
 
   @patch
+  static int _brokenDownDateToValue(
+      int year, int month, int day, int hour, int minute, int second,
+      int millisecond, int microsecond, bool isUtc) {
+    return Primitives.valueFromDecomposedDate(
+        year, month, day, hour, minute, second,
+        millisecond + _microsecondInRoundedMilliseconds(microsecond),
+        isUtc);
+  }
+
+  @patch
   String get timeZoneName {
     if (isUtc) return "UTC";
     return Primitives.getTimeZoneName(this);
   }
 
   @patch
   Duration get timeZoneOffset {
     if (isUtc) return new Duration();
     return new Duration(minutes: Primitives.getTimeZoneOffsetInMinutes(this));
   }
 
   @patch
+  DateTime add(Duration duration) {
+    return new DateTime._withValue(
+        _value + duration.inMilliseconds, isUtc: isUtc);
+  }
+
+  @patch
+  DateTime subtract(Duration duration) {
+    return new DateTime._withValue(
+        _value - duration.inMilliseconds, isUtc: isUtc);
+  }
+
+  @patch
+  Duration difference(DateTime other) {
+    return new Duration(milliseconds: _value - other._value);
+  }
+
+  @patch
+  int get millisecondsSinceEpoch => _value;
+
+  @patch
+  int get microsecondsSinceEpoch => _value * 1000;
+
+  @patch
   int get year => Primitives.getYear(this);
 
   @patch
   int get month => Primitives.getMonth(this);
 
   @patch
   int get day => Primitives.getDay(this);
 
   @patch
   int get hour => Primitives.getHours(this);
 
   @patch
   int get minute => Primitives.getMinutes(this);
 
   @patch
   int get second => Primitives.getSeconds(this);
 
   @patch
   int get millisecond => Primitives.getMilliseconds(this);
 
   @patch
+  int get microsecond => 0;
+
+  @patch
   int get weekday => Primitives.getWeekday(this);
 }
 
 
 // Patch for Stopwatch implementation.
 @patch
 class Stopwatch {
   @patch
   static void _initTicker() {
     Primitives.initTicker();
@@ skipping 50 matching lines @@
     return makeFixedListUnmodifiable/*<E>*/(result);
   }
 }
 
 @patch
 class Map<K, V> {
   @patch
   factory Map.unmodifiable(Map other) {
     return new UnmodifiableMapView<K, V>(new Map<K, V>.from(other));
   }
+
+  @patch
+  factory Map() = JsLinkedHashMap<K, V>.es6;
 }
 
 @patch
 class String {
   @patch
   factory String.fromCharCodes(Iterable<int> charCodes,
                                [int start = 0, int end]) {
     if (charCodes is JSArray) {
       return _stringFromJSArray(charCodes, start, end);
     }
@@ skipping 219 matching lines @@
       return getTraceFromException(error);
     }
     // Fallback if Error.captureStackTrace does not exist.
     try {
       throw '';
     } catch (_, stackTrace) {
       return stackTrace;
     }
   }
 }