Add Uri.isScheme test function.

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;
 
 // Frequently used character codes.
 const int _SPACE = 0x20;
 const int _PERCENT = 0x25;
 const int _PLUS = 0x2B;
@@ skipping 494 matching lines @@
    * Returns the origin of the URI in the form scheme://host:port for the
    * schemes http and https.
    *
    * It is an error if the scheme is not "http" or "https", or if the host name
    * is missing or empty.
    *
    * See: http://www.w3.org/TR/2011/WD-html5-20110405/origin-0.html#origin
    */
   String get origin;
 
+  /// Whether the scheme of this [Uri] is [scheme].
+  ///
+  /// The [scheme] should be the same as the one returned by [Uri.scheme],
+  /// but doesn't have to be case-normalized to lower-case characters.
+  ///
+  /// Example:
+  /// ```dart
+  /// var uri = Uri.parse("http://example.com/");
+  /// print(uri.isScheme("HTTP"));  // Prints true.
+  /// ```
+  ///
+  /// A `null` or empty [scheme] string matches a URI with no scheme
+  /// (one where [hasScheme] returns false).
+  bool isScheme(String scheme);
+
   /**
    * 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.
    *
    * For Windows semantics the backslash ("\\") separator is used to
@@ skipping 1000 matching lines @@
     if (scheme == "https") return 443;
     return 0;
   }
 
   String get path => _path;
 
   String get query => _query ?? "";
 
   String get fragment => _fragment ?? "";
 
+  bool isScheme(String scheme) {
+    String thisScheme = this.scheme;
+    if (scheme == null) return thisScheme.isEmpty;
+    if (scheme.length != thisScheme.length) return false;
+    return _compareScheme(scheme, thisScheme);
+  }
+
+  /// Compares scheme characters in [scheme] and at the start of [uri].
+  ///
+  /// Returns `true` if [scheme] represents the same scheme as the start of
+  /// [uri]. That means having the same characters, but possibly different case
+  /// for letters.
+  ///
+  /// This function doesn't check that the characters are valid URI scheme
+  /// characters. The [uri] is assumed to be valid, so if [scheme] matches
+  /// it, it has to be valid too.
+  ///
+  /// The length should be tested before calling this function,
+  /// so the scheme part of [uri] is known to have the same length as [scheme].
+  static bool _compareScheme(String scheme, String uri) {
+    for (int i = 0; i < scheme.length; i++) {
+      int schemeChar = scheme.codeUnitAt(i);
+      int uriChar = uri.codeUnitAt(i);
+      int delta = schemeChar ^ uriChar;
+      if (delta != 0) {
+        if (delta == 0x20) {
+          // Might be a case difference.
+          int lowerChar = uriChar | delta;
+          if (0x61 /*a*/ <= lowerChar && lowerChar <= 0x7a /*z*/) {
+            continue;
+          }
+        }
+        return false;
+      }
+    }
+    return true;
+  }
+
   // Report a parse failure.
   static void _fail(String uri, int index, String message) {
     throw new FormatException(message, uri, index);
   }
 
   static Uri _makeHttpUri(String scheme,
                           String authority,
                           String unencodedPath,
                           Map<String, String> queryParameters) {
     var userInfo = "";
@@ skipping 2519 matching lines @@
   bool get hasAuthority => _hostStart > 0;
   bool get hasUserInfo => _hostStart > _schemeEnd + 4;
   bool get hasPort => _hostStart > 0 && _portStart + 1 < _pathStart;
   bool get hasQuery => _queryStart < _fragmentStart;
   bool get hasFragment => _fragmentStart < _uri.length;
 
   bool get _isFile => _schemeEnd == 4 && _uri.startsWith("file");
   bool get _isHttp => _schemeEnd == 4 && _uri.startsWith("http");
   bool get _isHttps => _schemeEnd == 5 && _uri.startsWith("https");
   bool get _isPackage => _schemeEnd == 7 && _uri.startsWith("package");
+  /// Like [isScheme] but expects argument to be case normalized.
   bool _isScheme(String scheme) =>
     _schemeEnd == scheme.length && _uri.startsWith(scheme);
 
   bool get hasAbsolutePath => _uri.startsWith("/", _pathStart);
   bool get hasEmptyPath => _pathStart == _queryStart;
 
   bool get isAbsolute => hasScheme && !hasFragment;
 
+  bool isScheme(String scheme) {
+    if (scheme == null || scheme.isEmpty) return _schemeEnd < 0;
+    if (scheme.length != _schemeEnd) return false;
+    return _Uri._compareScheme(scheme, _uri);
+  }
+
   String get scheme {
     if (_schemeEnd <= 0) return "";
     if (_schemeCache != null) return _schemeCache;
     if (_isHttp) {
       _schemeCache = "http";
     } else if (_isHttps) {
       _schemeCache = "https";
     } else if (_isFile) {
       _schemeCache = "file";
     } else if (_isPackage) {
@@ skipping 414 matching lines @@
   int delta = (text.codeUnitAt(start + 4) ^ _COLON) * 3;
   delta |= text.codeUnitAt(start)     ^ 0x64 /*d*/;
   delta |= text.codeUnitAt(start + 1) ^ 0x61 /*a*/;
   delta |= text.codeUnitAt(start + 2) ^ 0x74 /*t*/;
   delta |= text.codeUnitAt(start + 3) ^ 0x61 /*a*/;
   return delta;
 }
 
 /// Helper function returning the length of a string, or `0` for `null`.
 int _stringOrNullLength(String s) => (s == null) ? 0 : s.length;