Omnibox - Do Not Allow HTTP/HTTPS Equivalence if User Explicitly Entered A Scheme

components/omnibox/autocomplete_match.h

Index: components/omnibox/autocomplete_match.h
diff --git a/components/omnibox/autocomplete_match.h b/components/omnibox/autocomplete_match.h
index 8fd50acfc0d613e37eab609a43795be514ae9b58..da8510e83617cd79a6072eaee4afe7a425cacb9a 100644
--- a/components/omnibox/autocomplete_match.h
+++ b/components/omnibox/autocomplete_match.h
@@ -183,14 +183,18 @@ struct AutocompleteMatch {
   // left empty and the template URL (if any) is determined from the
   // destination's hostname.  The template URL is used to strip off query args
   // other than the search terms themselves that would otherwise prevent doing
-  // proper deduping.
+  // proper deduping.  If |scheme_explicitly_entered| then the scheme is not
+  // allowed to be altered during stripping, thus preventing two URLs with
+  // different schemes from having the same stripped GURL.

[Peter Kasting, 2015/04/25 00:03:12]

Hmm, this doesn't seem quite right.

Consider user input of some version of "foo.com" and matches for various origins
from foo.com and bar.com.

Whether the user explicitly types a scheme should affect deduping of foo.com
matches, but I don't think it should affect deduping of bar.com ones.  That is:

"foo.com" -> user doesn't care about http://foo.com vs. https://foo.com
"http[s]://foo.com" -> user does care about the difference;
...but in both cases, user doesn't care about http://bar.com vs. https://bar.com

Thinking about this more, in conjunction with my comment above about "www.", I
realize that this issue is this:

Given a particular user input, we might normally mark as dupes matches where one
match is inlineable and one is not.  Instead we should be unwilling to dupe two
matches if their inlineability differs.

In the case above, when typing "foo.com", all variants of foo.com (http vs.
https, www. vs. no-www.) are inlineable.  So it's safe to dupe one against
another.  Likewise, all variants of bar.com are non-inlineable, and again, it's
safe to dupe.

But if the user types "http://foo.com", then the two "http" forms of "foo.com"
are still inlineable, but the "https" forms aren't.  We should allow duping
within each pair, but not across pairs.  And if the user types
"https://www.foo.com", then none of the other forms can be inlined against that,
so none should be duped against it.  Meanwhile, none of these inputs changes the
(non-)inlineability of the bar.com matches, so those should all still be
dupeable.

So, basically, I think the answer is to pass in sufficient info about the user's
typing to understand whether some of the things we'd normally strip were
explicitly present in the original typing _and the hostnames are the same_, and
if so, don't strip those things.

[Mark P, 2015/04/27 22:26:05]

Astute analysis.

Here's a follow-up question: if a user types "https foo", do you want to prevent
http/https matches getting dupped together?

   static GURL GURLToStrippedGURL(const GURL& url,
+                                 const bool scheme_explicitly_entered,
                                  TemplateURLService* template_url_service,
                                  const base::string16& keyword);
 
   // Computes the stripped destination URL (via GURLToStrippedGURL()) and
   // stores the result in |stripped_destination_url|.
-  void ComputeStrippedDestinationURL(TemplateURLService* template_url_service);
+  void ComputeStrippedDestinationURL(const bool scheme_explicitly_entered,
+                                     TemplateURLService* template_url_service);
 
   // Sets |allowed_to_be_default_match| to true if this match is effectively
   // the URL-what-you-typed match (i.e., would be dupped against the UWYT
@@ -198,6 +202,7 @@ struct AutocompleteMatch {
   // the AutocompleteInput interpreted as a URL (i.e.,
   // AutocompleteInput::canonicalized_url()).
   void EnsureUWYTIsAllowedToBeDefault(const GURL& canonical_input_url,
+                                      const bool scheme_explicitly_entered,
                                       TemplateURLService* template_url_service);
 
   // Gets data relevant to whether there should be any special keyword-related