Rename new Uri.fromString to Uri.parse.

tests/utils/uri_test.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.
 
 library uriTest;
 
 import 'dart:utf';
 import 'dart:uri';
 
 testUri(String uri, bool isAbsolute) {
-  Expect.equals(isAbsolute, new Uri.fromString(uri).isAbsolute());
+  Expect.equals(isAbsolute, Uri.parse(uri).isAbsolute());
   Expect.equals(isAbsolute, new Uri(uri).isAbsolute());
-  Expect.stringEquals(uri, new Uri.fromString(uri).toString());
+  Expect.stringEquals(uri, Uri.parse(uri).toString());
   Expect.stringEquals(uri, new Uri(uri).toString());
 
   // Test equals and hashCode members.
   Expect.equals(new Uri(uri), new Uri(uri));
   Expect.equals(new Uri(uri).hashCode, new Uri(uri).hashCode);
 }
 
 testEncodeDecode(String orig, String encoded) {
   var e = encodeUri(orig);
   Expect.stringEquals(encoded, e);
@@ skipping 82 matching lines @@
                           fragment: "fragment").toString());
   Expect.stringEquals("null://null@null/a/b/c/?null#null",
                       const Uri.fromComponents(
                           scheme: null,
                           userInfo: null,
                           domain: null,
                           port: 0,
                           path: "/a/b/c/",
                           query: null,
                           fragment: null).toString());
-  Expect.stringEquals("file://", new Uri.fromString("file:").toString());
+  Expect.stringEquals("file://", Uri.parse("file:").toString());
   Expect.stringEquals("file://", new Uri("file:").toString());
   Expect.stringEquals("/a/g", removeDotSegments("/a/b/c/./../../g"));
   Expect.stringEquals("mid/6", removeDotSegments("mid/content=5/../6"));
   Expect.stringEquals("a/b/e", removeDotSegments("a/b/c/d/../../e"));
   Expect.stringEquals("a/b/e", removeDotSegments("../a/b/c/d/../../e"));
   Expect.stringEquals("a/b/e", removeDotSegments("./a/b/c/d/../../e"));
   Expect.stringEquals("a/b/e", removeDotSegments("../a/b/./c/d/../../e"));
   Expect.stringEquals("a/b/e", removeDotSegments("./a/b/./c/d/../../e"));
   Expect.stringEquals("a/b/e/", removeDotSegments("./a/b/./c/d/../../e/."));
   Expect.stringEquals("a/b/e/", removeDotSegments("./a/b/./c/d/../../e/./."));
   Expect.stringEquals("a/b/e/", removeDotSegments("./a/b/./c/d/../../e/././."));
 
   final urisSample = "http://a/b/c/d;p?q";
-  Uri baseFromString = new Uri.fromString(urisSample);
+  Uri baseFromString = Uri.parse(urisSample);
   testUriPerRFCs(baseFromString);
   Uri base = new Uri(urisSample);
   testUriPerRFCs(base);
 
   Expect.stringEquals(
       "http://example.com",
-      new Uri.fromString("http://example.com/a/b/c").origin);
+      Uri.parse("http://example.com/a/b/c").origin);
   Expect.stringEquals(
       "https://example.com",
-      new Uri.fromString("https://example.com/a/b/c").origin);
+      Uri.parse("https://example.com/a/b/c").origin);
   Expect.stringEquals(
       "http://example.com:1234",
-      new Uri.fromString("http://example.com:1234/a/b/c").origin);
+      Uri.parse("http://example.com:1234/a/b/c").origin);
   Expect.stringEquals(
       "https://example.com:1234",
-      new Uri.fromString("https://example.com:1234/a/b/c").origin);
+      Uri.parse("https://example.com:1234/a/b/c").origin);
   Expect.throws(
-      () => new Uri.fromString("http:").origin,
+      () => Uri.parse("http:").origin,
       (e) { return e is ArgumentError; },
       "origin for uri with empty domain should fail");
   Expect.throws(
       () => const Uri.fromComponents(
           scheme: "http",
           userInfo: null,
           domain: "",
           port: 80,
           path: "/a/b/c",
           query: "query",
@@ skipping 16 matching lines @@
           scheme: "http",
           userInfo: null,
           domain: null,
           port: 80,
           path: "/a/b/c",
           query: "query",
           fragment: "fragment").origin,
       (e) { return e is ArgumentError; },
       "origin for uri with empty domain should fail");
   Expect.throws(
-      () => new Uri.fromString("http://:80").origin,
+      () => Uri.parse("http://:80").origin,
       (e) { return e is ArgumentError; },
       "origin for uri with empty domain should fail");
   Expect.throws(
-      () => new Uri.fromString("file://localhost/test.txt").origin,
+      () => Uri.parse("file://localhost/test.txt").origin,
       (e) { return e is ArgumentError; },
       "origin for non-http/https uri should fail");
 
   // URI encode tests
   // Create a string with code point 0x10000 encoded as a surrogate pair.
   var s = decodeUtf8([0xf0, 0x90, 0x80, 0x80]);
 
   Expect.stringEquals("\u{10000}", s);
 
   testEncodeDecode("A + B", "A+%2B+B");
   testEncodeDecode("\uFFFE", "%EF%BF%BE");
   testEncodeDecode("\uFFFF", "%EF%BF%BF");
   testEncodeDecode("\uFFFE", "%EF%BF%BE");
   testEncodeDecode("\uFFFF", "%EF%BF%BF");
   testEncodeDecode("\x7f", "%7F");
   testEncodeDecode("\x80", "%C2%80");
   testEncodeDecode("\u0800", "%E0%A0%80");
   testEncodeDecode(":/@',;?&=+\$", ":/@',;?&=%2B\$");
   testEncodeDecode(s, "%F0%90%80%80");
   testEncodeDecodeComponent("\uFFFE", "%EF%BF%BE");
   testEncodeDecodeComponent("\uFFFF", "%EF%BF%BF");
   testEncodeDecodeComponent("\uFFFE", "%EF%BF%BE");
   testEncodeDecodeComponent("\uFFFF", "%EF%BF%BF");
   testEncodeDecodeComponent("\x7f", "%7F");
   testEncodeDecodeComponent("\x80", "%C2%80");
   testEncodeDecodeComponent("\u0800", "%E0%A0%80");
   testEncodeDecodeComponent(":/@',;?&=+\$", "%3A%2F%40'%2C%3B%3F%26%3D%2B%24");
   testEncodeDecodeComponent(s, "%F0%90%80%80");
 }