Proof-read comments in src/url/.

url/url_canon.h

 // 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.
 
 #ifndef URL_URL_CANON_H_
 #define URL_URL_CANON_H_
 
 #include <stdlib.h>
 #include <string.h>
 
@@ skipping 267 matching lines @@
                                    CanonOutput* output,
                                    Component* out_scheme);
 URL_EXPORT bool CanonicalizeScheme(const base::char16* spec,
                                    const Component& scheme,
                                    CanonOutput* output,
                                    Component* out_scheme);
 
 // User info: username/password. If present, this will add the delimiters so
 // the output will be "<username>:<password>@" or "<username>@". Empty
 // username/password pairs, or empty passwords, will get converted to
-// nonexistant in the canonical version.
+// nonexistent in the canonical version.
 //
 // The components for the username and password refer to ranges in the
 // respective source strings. Usually, these will be the same string, which
 // is legal as long as the two components don't overlap.
 //
 // The 8-bit version requires UTF-8 encoding.
 URL_EXPORT bool CanonicalizeUserInfo(const char* username_source,
                                      const Component& username,
                                      const char* password_source,
                                      const Component& password,
@@ skipping 11 matching lines @@
 // This structure holds detailed state exported from the IP/Host canonicalizers.
 // Additional fields may be added as callers require them.
 struct CanonHostInfo {
   CanonHostInfo() : family(NEUTRAL), num_ipv4_components(0), out_host() {}
 
   // Convenience function to test if family is an IP address.
   bool IsIPAddress() const { return family == IPV4 || family == IPV6; }
 
   // This field summarizes how the input was classified by the canonicalizer.
   enum Family {
-    NEUTRAL,   // - Doesn't resemble an IP address.  As far as the IP
+    NEUTRAL,   // - Doesn't resemble an IP address. As far as the IP
                //   canonicalizer is concerned, it should be treated as a
                //   hostname.
-    BROKEN,    // - Almost an IP, but was not canonicalized.  This could be an
+    BROKEN,    // - Almost an IP, but was not canonicalized. This could be an
                //   IPv4 address where truncation occurred, or something
                //   containing the special characters :[] which did not parse
-               //   as an IPv6 address.  Never attempt to connect to this
+               //   as an IPv6 address. Never attempt to connect to this
                //   address, because it might actually succeed!
     IPV4,      // - Successfully canonicalized as an IPv4 address.
     IPV6,      // - Successfully canonicalized as an IPv6 address.
   };
   Family family;
 
   // If |family| is IPV4, then this is the number of nonempty dot-separated
-  // components in the input text, from 1 to 4.  If |family| is not IPV4,
+  // components in the input text, from 1 to 4. If |family| is not IPV4,
   // this value is undefined.
   int num_ipv4_components;
 
   // Location of host within the canonicalized output.
   // CanonicalizeIPAddress() only sets this field if |family| is IPV4 or IPV6.
   // CanonicalizeHostVerbose() always sets it.
   Component out_host;
 
   // |address| contains the parsed IP Address (if any) in its first
   // AddressLength() bytes, in network order. If IsIPAddress() is false
   // AddressLength() will return zero and the content of |address| is undefined.
   unsigned char address[16];
 
   // Convenience function to calculate the length of an IP address corresponding
   // to the current IP version in |family|, if any. For use with |address|.
   int AddressLength() const {
     return family == IPV4 ? 4 : (family == IPV6 ? 16 : 0);
   }
 };
 
 
 // Host.
 //
-// The 8-bit version requires UTF-8 encoding.  Use this version when you only
+// The 8-bit version requires UTF-8 encoding. Use this version when you only
 // need to know whether canonicalization succeeded.
 URL_EXPORT bool CanonicalizeHost(const char* spec,
                                  const Component& host,
                                  CanonOutput* output,
                                  Component* out_host);
 URL_EXPORT bool CanonicalizeHost(const base::char16* spec,
                                  const Component& host,
                                  CanonOutput* output,
                                  Component* out_host);
 
 // Extended version of CanonicalizeHost, which returns additional information.
 // Use this when you need to know whether the hostname was an IP address.
-// A successful return is indicated by host_info->family != BROKEN.  See the
+// A successful return is indicated by host_info->family != BROKEN. See the
 // definition of CanonHostInfo above for details.
 URL_EXPORT void CanonicalizeHostVerbose(const char* spec,
                                         const Component& host,
                                         CanonOutput* output,
                                         CanonHostInfo* host_info);
 URL_EXPORT void CanonicalizeHostVerbose(const base::char16* spec,
                                         const Component& host,
                                         CanonOutput* output,
                                         CanonHostInfo* host_info);
 
@@ skipping 165 matching lines @@
                                     int spec_len,
                                     const Parsed& parsed,
                                     CanonOutput* output,
                                     Parsed* new_parsed);
 URL_EXPORT bool CanonicalizePathURL(const base::char16* spec,
                                     int spec_len,
                                     const Parsed& parsed,
                                     CanonOutput* output,
                                     Parsed* new_parsed);
 
-// Use for mailto URLs. This "canonicalizes" the url into a path and query
+// Use for mailto URLs. This "canonicalizes" the URL into a path and query
 // component. It does not attempt to merge "to" fields. It uses UTF-8 for
 // the query encoding if there is a query. This is because a mailto URL is
 // really intended for an external mail program, and the encoding of a page,
 // etc. which would influence a query encoding normally are irrelevant.
 URL_EXPORT bool CanonicalizeMailtoURL(const char* spec,
                                       int spec_len,
                                       const Parsed& parsed,
                                       CanonOutput* output,
                                       Parsed* new_parsed);
 URL_EXPORT bool CanonicalizeMailtoURL(const base::char16* spec,
                                       int spec_len,
                                       const Parsed& parsed,
                                       CanonOutput* output,
                                       Parsed* new_parsed);
 
 // Part replacer --------------------------------------------------------------
 
 // Internal structure used for storing separate strings for each component.
 // The basic canonicalization functions use this structure internally so that
 // component replacement (different strings for different components) can be
 // treated on the same code path as regular canonicalization (the same string
 // for each component).
 //
-// A Parsed structure usually goes along with this. Those
-// components identify offsets within these strings, so that they can all be
-// in the same string, or spread arbitrarily across different ones.
+// A Parsed structure usually goes along with this. Those components identify
+// offsets within these strings, so that they can all be in the same string,
+// or spread arbitrarily across different ones.
 //
 // This structures does not own any data. It is the caller's responsibility to
 // ensure that the data the pointers point to stays in scope and is not
 // modified.
 template<typename CHAR>
 struct URLComponentSource {
   // Constructor normally used by callers wishing to replace components. This
   // will make them all NULL, which is no replacement. The caller would then
   // override the components they want to replace.
   URLComponentSource()
@@ skipping 124 matching lines @@
   void SetRef(const CHAR* s, const Component& comp) {
     sources_.ref = s;
     components_.ref = comp;
   }
   void ClearRef() {
     sources_.ref = Placeholder();
     components_.ref = Component();
   }
   bool IsRefOverridden() const { return sources_.ref != NULL; }
 
-  // Getters for the itnernal data. See the variables below for how the
+  // Getters for the internal data. See the variables below for how the
   // information is encoded.
   const URLComponentSource<CHAR>& sources() const { return sources_; }
   const Parsed& components() const { return components_; }
 
  private:
   // Returns a pointer to a static empty string that is used as a placeholder
   // to indicate a component should be deleted (see below).
   const CHAR* Placeholder() {
     static const CHAR empty_cstr = 0;
     return &empty_cstr;
@@ skipping 117 matching lines @@
 // and the identified relevant portion of the relative URL (computed by
 // IsRelativeURL), this produces a new parsed canonical URL in |output| and
 // |out_parsed|.
 //
 // It also requires a flag indicating whether the base URL is a file: URL
 // which triggers additional logic.
 //
 // The base URL should be canonical and have a host (may be empty for file
 // URLs) and a path. If it doesn't have these, we can't resolve relative
 // URLs off of it and will return the base as the output with an error flag.
-// Becausee it is canonical is should also be ASCII.
+// Because it is canonical is should also be ASCII.
 //
 // The query charset converter follows the same rules as CanonicalizeQuery.
 //
 // Returns true on success. On failure, the output will be "something
 // reasonable" that will be consistent and valid, just probably not what
 // was intended by the web page author or caller.
 URL_EXPORT bool ResolveRelativeURL(const char* base_url,
                                    const Parsed& base_parsed,
                                    bool base_is_file,
                                    const char* relative_url,
                                    const Component& relative_component,
                                    CharsetConverter* query_converter,
                                    CanonOutput* output,
                                    Parsed* out_parsed);
 URL_EXPORT bool ResolveRelativeURL(const char* base_url,
                                    const Parsed& base_parsed,
                                    bool base_is_file,
                                    const base::char16* relative_url,
                                    const Component& relative_component,
                                    CharsetConverter* query_converter,
                                    CanonOutput* output,
                                    Parsed* out_parsed);
 
 }  // namespace url
 
 #endif  // URL_URL_CANON_H_