Proof-read comments in src/url/.

url/url_parse_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "url/third_party/mozilla/url_parse.h"
 
 #include "base/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/third_party/mozilla/url_parse.h"
 
@@ skipping 72 matching lines @@
   int inner_port;
   const char* inner_path;
   const char* path;
   const char* query;
   const char* ref;
 };
 
 bool ComponentMatches(const char* input,
                       const char* reference,
                       const Component& component) {
-  // If the component is nonexistant (length == -1), it should begin at 0.
+  // If the component is nonexistent (length == -1), it should begin at 0.
   EXPECT_TRUE(component.len >= 0 || component.len == -1);
 
   // Begin should be valid.
   EXPECT_LE(0, component.begin);
 
-  // A NULL reference means the component should be nonexistant.
+  // A NULL reference means the component should be nonexistent.
   if (!reference)
     return component.len == -1;
   if (component.len < 0)
     return false;  // Reference is not NULL but we don't have anything
 
   if (strlen(reference) != static_cast<size_t>(component.len))
     return false;  // Lengths don't match
 
   // Now check the actual characters.
   return strncmp(reference, &input[component.begin], component.len) == 0;
@@ skipping 228 matching lines @@
 {"/",                                       NULL,          "/"},
 {" This is \\interesting// \t",             NULL,          "This is \\interesting// \t"},
 {"about:",                                  "about",       NULL},
 {"about:blank",                             "about",       "blank"},
 {"  about: blank ",                         "about",       " blank "},
 {"javascript :alert(\"He:/l\\l#o?foo\"); ", "javascript ", "alert(\"He:/l\\l#o?foo\"); "},
 };
 
 TEST(URLParser, PathURL) {
   // Declared outside for loop to try to catch cases in init() where we forget
-  // to reset something that is reset by the construtor.
+  // to reset something that is reset by the constructor.
   Parsed parsed;
   for (size_t i = 0; i < arraysize(path_cases); i++) {
     const char* url = path_cases[i].input;
     ParsePathURL(url, static_cast<int>(strlen(url)), false, &parsed);
 
     EXPECT_TRUE(ComponentMatches(url, path_cases[i].scheme, parsed.scheme))
         << i;
     EXPECT_TRUE(ComponentMatches(url, path_cases[i].path, parsed.GetContent()))
         << i;
 
-    // The remaining components are never used for path urls.
+    // The remaining components are never used for path URLs.
     ExpectInvalidComponent(parsed.username);
     ExpectInvalidComponent(parsed.password);
     ExpectInvalidComponent(parsed.host);
     ExpectInvalidComponent(parsed.port);
   }
 }
 
 // Various incarnations of file URLs.
 static URLParseCase file_cases[] = {
 #ifdef WIN32
@@ skipping 160 matching lines @@
                            const char* expected_value) {
   Parsed parsed;
   ParseStandardURL(url, static_cast<int>(strlen(url)), &parsed);
 
   Component query = parsed.query;
 
   for (int i = 1; i <= parameter; i++) {
     Component key, value;
     if (!ExtractQueryKeyValue(url, &query, &key, &value)) {
       if (parameter >= i && !expected_key)
-        return true;  // Expected nonexistant key, got one.
+        return true;  // Expected nonexistent key, got one.
       return false;  // Not enough keys.
     }
 
     if (i == parameter) {
       if (!expected_key)
         return false;
 
       if (strncmp(&url[key.begin], expected_key, key.len) != 0)
         return false;
       if (strncmp(&url[value.begin], expected_value, value.len) != 0)
@@ skipping 55 matching lines @@
 {"mailto:addr1:addr2 ",         "mailto", "addr1:addr2",      NULL},
 {"mailto:?to=addr1,addr2",      "mailto", NULL,               "to=addr1,addr2"},
 {"mailto:?to=addr1%2C%20addr2", "mailto", NULL,               "to=addr1%2C%20addr2"},
 {"mailto:addr1?to=addr2",       "mailto", "addr1",            "to=addr2"},
 {"mailto:?body=#foobar#",       "mailto", NULL,               "body=#foobar#",},
 {"mailto:#?body=#foobar#",      "mailto", "#",                "body=#foobar#"},
 };
 
 TEST(URLParser, MailtoUrl) {
   // Declared outside for loop to try to catch cases in init() where we forget
-  // to reset something that is reset by the construtor.
+  // to reset something that is reset by the constructor.
   Parsed parsed;
   for (size_t i = 0; i < arraysize(mailto_cases); ++i) {
     const char* url = mailto_cases[i].input;
     ParseMailtoURL(url, static_cast<int>(strlen(url)), &parsed);
     int port = ParsePort(url, parsed.port);
 
     EXPECT_TRUE(ComponentMatches(url, mailto_cases[i].scheme, parsed.scheme));
     EXPECT_TRUE(ComponentMatches(url, mailto_cases[i].path, parsed.path));
     EXPECT_TRUE(ComponentMatches(url, mailto_cases[i].query, parsed.query));
     EXPECT_EQ(PORT_UNSPECIFIED, port);
 
-    // The remaining components are never used for mailto urls.
+    // The remaining components are never used for mailto URLs.
     ExpectInvalidComponent(parsed.username);
     ExpectInvalidComponent(parsed.password);
     ExpectInvalidComponent(parsed.port);
     ExpectInvalidComponent(parsed.ref);
   }
 }
 
 // Various incarnations of filesystem URLs.
 static FileSystemURLParseCase filesystem_cases[] = {
   // Regular URL with all the parts
 {"filesystem:http://user:pass@foo:21/temporary/bar;par?b#c", "http",  "user", "pass", "foo", 21, "/temporary",  "/bar;par",  "b",  "c"},
 {"filesystem:https://foo/persistent/bar;par/",               "https", NULL,   NULL,   "foo", -1, "/persistent", "/bar;par/", NULL, NULL},
 {"filesystem:file:///persistent/bar;par/",                   "file", NULL,    NULL,   NULL,  -1, "/persistent", "/bar;par/", NULL, NULL},
 {"filesystem:file:///persistent/bar;par/?query#ref",                   "file", NULL,    NULL,   NULL,  -1, "/persistent", "/bar;par/", "query", "ref"},
 {"filesystem:file:///persistent",                            "file", NULL,    NULL,   NULL,  -1, "/persistent", "",        NULL, NULL},
 };
 
 TEST(URLParser, FileSystemURL) {
   // Declared outside for loop to try to catch cases in init() where we forget
-  // to reset something that is reset by the construtor.
+  // to reset something that is reset by the constructor.
   Parsed parsed;
   for (size_t i = 0; i < arraysize(filesystem_cases); i++) {
     const FileSystemURLParseCase* parsecase = &filesystem_cases[i];
     const char* url = parsecase->input;
     ParseFileSystemURL(url, static_cast<int>(strlen(url)), &parsed);
 
     EXPECT_TRUE(ComponentMatches(url, "filesystem", parsed.scheme));
     EXPECT_EQ(!parsecase->inner_scheme, !parsed.inner_parsed());
     // Only check the inner_parsed if there is one.
     if (parsed.inner_parsed()) {
       EXPECT_TRUE(ComponentMatches(url, parsecase->inner_scheme,
           parsed.inner_parsed()->scheme));
       EXPECT_TRUE(ComponentMatches(url, parsecase->inner_username,
           parsed.inner_parsed()->username));
       EXPECT_TRUE(ComponentMatches(url, parsecase->inner_password,
           parsed.inner_parsed()->password));
       EXPECT_TRUE(ComponentMatches(url, parsecase->inner_host,
           parsed.inner_parsed()->host));
       int port = ParsePort(url, parsed.inner_parsed()->port);
       EXPECT_EQ(parsecase->inner_port, port);
 
-      // The remaining components are never used for filesystem urls.
+      // The remaining components are never used for filesystem URLs.
       ExpectInvalidComponent(parsed.inner_parsed()->query);
       ExpectInvalidComponent(parsed.inner_parsed()->ref);
     }
 
     EXPECT_TRUE(ComponentMatches(url, parsecase->path, parsed.path));
     EXPECT_TRUE(ComponentMatches(url, parsecase->query, parsed.query));
     EXPECT_TRUE(ComponentMatches(url, parsecase->ref, parsed.ref));
 
-    // The remaining components are never used for filesystem urls.
+    // The remaining components are never used for filesystem URLs.
     ExpectInvalidComponent(parsed.username);
     ExpectInvalidComponent(parsed.password);
     ExpectInvalidComponent(parsed.host);
     ExpectInvalidComponent(parsed.port);
   }
 }
 
 }  // namespace
 }  // namespace url