PlzNavigate: identify same-page browser-initiated navigation.

url/url_util.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_UTIL_H_
 #define URL_URL_UTIL_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 158 matching lines @@
 // If either of the input StringPieces is empty, the return value is false. The
 // input domain should be a lower-case ASCII string in order to match the
 // canonicalized host.
 URL_EXPORT bool DomainIs(base::StringPiece canonicalized_host,
                          base::StringPiece lower_ascii_domain);
 
 // Returns true if the hostname is an IP address. Note: this function isn't very
 // cheap, as it must re-parse the host to verify.
 URL_EXPORT bool HostIsIPAddress(base::StringPiece host);
 
+// Fragment --------------------------------------------------------------------
+
+// Checks whether or not two URLs are differing only in the fragment (the part
+// after the # character). Returns false when the new URL has no fragment.
+URL_EXPORT bool IsFragmentAddedOrUpdated(const GURL& old_url,

[brettw, 2017/01/26 20:44:46]

Several points:

Regarding the naming: This code uses the term "ref" for the reference fragment
rather than "fragment". The naming of "changed" implies a temporal change which
may make sense in terms of the caller in navigator_impl.cc but makes less sense
to me in terms of a function taking two parameters.

This function is being used to compute whether the navigation is in-page. If the
2nd parameter has no ref or the URLs are equal, it doesn't imply to me that the
navigation is *not* in page. This seems like pretty strange semantics to me. Are
you sure this is what you want? If it is, this seems to be something specific to
the rules of how Blink sends us navigation messages rather than an intrinsic
property of URLs, and this exact behavior would be better implemented in the
navigation layer.

KURL has a function equalIgnoringFragmentIdentifier. This seems very easy to
reason about. I would be happy adding a GURL::EqualsIgnoringRef function and
then you wrap that in the navigation layer if there are extra rules you want to
implement on top of that about navigating from refs to no refs.



url_util is at a conceptually lower layer than GURL: it provides the common
backing for GURL and KURL. Functions dealing with GURL should go on the GURL
object.



Implementation:

The implementation is pretty heavyweight, involving reallocating and
recanonicalizing two URLs just for comparison. At this low layer, I think the
operations should be more optimized. To do this, call
Parsed::CountCharactersBefore(REF, <not_sure>) and compare the string pieces of
the computed prefix to see if the URLs are equivalent ignoring the ref.

+                                         const GURL& new_url);
+
 // URL library wrappers --------------------------------------------------------
 
 // Parses the given spec according to the extracted scheme type. Normal users
 // should use the URL object, although this may be useful if performance is
 // critical and you don't want to do the heap allocation for the std::string.
 //
 // As with the Canonicalize* functions, the charset converter can
 // be NULL to use UTF-8 (it will be faster in this case).
 //
 // Returns true if a valid URL was produced, false if not. On failure, the
@@ skipping 68 matching lines @@
 
 // Escapes the given string as defined by the JS method encodeURIComponent. See
 // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/encodeURIComponent
 URL_EXPORT void EncodeURIComponent(const char* input,
                                    int length,
                                    CanonOutput* output);
 
 }  // namespace url
 
 #endif  // URL_URL_UTIL_H_