Return the correct port from Uri, when port is 0 and scheme is either http or https.

sdk/lib/core/uri.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.
 
 part of dart.core;
 
 /**
  * A parsed URI, as specified by RFC-3986, http://tools.ietf.org/html/rfc3986.
  */
 class Uri {
@@ skipping 45 matching lines @@
       return _host.substring(1, _host.length - 1);
     }
     return _host;
   }
 
   /**
    * Returns the port part of the authority component.
    *
    * Returns 0 if there is no port in the authority component.
    */
-  int get port => _port;
+  int get port {
+    if (_port == 0) {
+      if (scheme == "http") return 80;
+      if (scheme == "https") return 443;
+    }
+    return _port;
+  }
 
   /**
    * Returns the path component.
    *
    * The returned path is encoded. To get direct access to the decoded
    * path use [pathSegments].
    *
    * Returns the empty string if there is no path component.
    */
   String get path => _path;
@@ skipping 23 matching lines @@
    * Cache the computed return value of [queryParameters].
    */
   Map<String, String> _queryParameters;
 
   /**
    * Creates a new URI object by parsing a URI string.
    */
   static Uri parse(String uri) => new Uri._fromMatch(_splitRe.firstMatch(uri));
 
   Uri._fromMatch(Match m) :
-    this(scheme: _emptyIfNull(m[_COMPONENT_SCHEME]),
+    this(scheme: _makeScheme(_emptyIfNull(m[_COMPONENT_SCHEME])),
          userInfo: _emptyIfNull(m[_COMPONENT_USER_INFO]),
          host: _eitherOf(
          m[_COMPONENT_HOST], m[_COMPONENT_HOST_IPV6]),
          port: _parseIntOrZero(m[_COMPONENT_PORT]),
          path: _emptyIfNull(m[_COMPONENT_PATH]),
          query: _emptyIfNull(m[_COMPONENT_QUERY_DATA]),
          fragment: _emptyIfNull(m[_COMPONENT_FRAGMENT]));
 
   /**
    * Creates a new URI from its components.
@@ skipping 401 matching lines @@
 
     bool isSchemeCharacter(int ch) {
       return ch < 128 && ((_schemeTable[ch >> 4] & (1 << (ch & 0x0f))) != 0);
     }
 
     if (scheme == null) return "";
     bool allLowercase = true;
     int length = scheme.length;
     for (int i = 0; i < length; i++) {
       int codeUnit = scheme.codeUnitAt(i);
+      if (i == 0 && !_isAlphabeticCharacter(codeUnit)) {
+        // First code unit must be an alphabetic character.
+        throw new ArgumentError('Illegal scheme: $scheme');
+      }
       if (!isSchemeLowerCharacter(codeUnit)) {
         if (isSchemeCharacter(codeUnit)) {
           allLowercase = false;
         } else {
           throw new ArgumentError('Illegal scheme: $scheme');
         }
       }
     }
 
     return allLowercase ? scheme : scheme.toLowerCase();
@@ skipping 161 matching lines @@
   static String _eitherOf(String val1, String val2) {
     if (val1 != null) return val1;
     if (val2 != null) return val2;
     return '';
   }
 
   // NOTE: This code was ported from: closure-library/closure/goog/uri/utils.js
   static final RegExp _splitRe = new RegExp(
       '^'
       '(?:'
-        '([^:/?#.]+)'                   // scheme - ignore special characters
+        '([^:/?#]+)'                    // scheme - ignore special characters
                                         // used by other URL parts such as :,
                                         // ?, /, #, and .
       ':)?'
       '(?://'
         '(?:([^/?#]*)@)?'               // userInfo
         '(?:'
           r'([\w\d\-\u0100-\uffff.%]*)'
                                         // host - restrict to letters,
                                         // digits, dashes, dots, percent
                                         // escapes, and unicode characters.
@@ skipping 144 matching lines @@
    * See: http://www.w3.org/TR/2011/WD-html5-20110405/origin-0.html#origin
    */
   String get origin {
     if (scheme == "" || _host == null || _host == "") {
       throw new StateError("Cannot use origin without a scheme: $this");
     }
     if (scheme != "http" && scheme != "https") {
       throw new StateError(
         "Origin is only applicable schemes http and https: $this");
     }
-    if (port == 0) return "$scheme://$_host";
-    return "$scheme://$_host:$port";
+    if (_port == 0) return "$scheme://$_host";
+    return "$scheme://$_host:$_port";
   }
 
   /**
    * Returns the file path from a file URI.
    *
    * The returned path has either Windows or non-Windows
    * semantics.
    *
    * For non-Windows semantics the slash ("/") is used to separate
    * path segments.
@@ skipping 111 matching lines @@
   }
 
   bool get _isPathAbsolute {
     if (path == null || path.isEmpty) return false;
     return path.startsWith('/');
   }
 
   void _writeAuthority(StringSink ss) {
     _addIfNonEmpty(ss, userInfo, userInfo, "@");
     ss.write(_host == null ? "null" : _host);
-    if (port != 0) {
+    if (_port != 0) {
       ss.write(":");
-      ss.write(port.toString());
+      ss.write(_port.toString());
     }
   }
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     _addIfNonEmpty(sb, scheme, scheme, ':');
     if (hasAuthority || (scheme == "file")) {
       sb.write("//");
       _writeAuthority(sb);
     }
@@ skipping 423 matching lines @@
           i += 2;
           if (i == text.length) break;
           ch = text.codeUnitAt(i);
         }
         result.write(encoding.decode(codepoints));
       }
     }
     return result.toString();
   }
 
+  static bool _isAlphabeticCharacter(int codeUnit)
+    => (codeUnit >= _LOWER_CASE_A && codeUnit <= _LOWER_CASE_Z) ||
+       (codeUnit >= _UPPER_CASE_A && codeUnit <= _UPPER_CASE_Z);
+
   // Tables of char-codes organized as a bit vector of 128 bits where
   // each bit indicate whether a character code on the 0-127 needs to
   // be escaped or not.
 
   // The unreserved characters of RFC 3986.
   static const _unreservedTable = const [
                 //             LSB            MSB
                 //              |              |
       0x0000,   // 0x00 - 0x0f  0000000000000000
       0x0000,   // 0x10 - 0x1f  0000000000000000
@@ skipping 174 matching lines @@
   void clear() {
     throw new UnsupportedError("Cannot modify an unmodifiable map");
   }
   void forEach(void f(K key, V value)) => _map.forEach(f);
   Iterable<K> get keys => _map.keys;
   Iterable<V> get values => _map.values;
   int get length => _map.length;
   bool get isEmpty => _map.isEmpty;
   bool get isNotEmpty => _map.isNotEmpty;
 }