Avoid DCHECK failure for chrome:// URLs in autocomplete suggestions

components/omnibox/browser/physical_web_provider.cc

 // Copyright (c) 2016 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 "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "components/omnibox/browser/autocomplete_provider_client.h"
 #include "components/omnibox/browser/autocomplete_provider_listener.h"
+#include "components/omnibox/browser/history_url_provider.h"
 #include "components/omnibox/browser/physical_web_provider.h"
+#include "components/omnibox/browser/verbatim_match.h"
 #include "components/physical_web/data_source/physical_web_data_source.h"
 #include "components/url_formatter/url_formatter.h"
 #include "grit/components_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
 
 namespace {
 
 // The maximum number of match results to provide. If the number of nearby URLs
 // exceeds this limit, an overflow item is created. Tapping the overflow item
@@ skipping 10 matching lines @@
 // Relevance score of the first Physical Web URL autocomplete match. This score
 // is intended to be between ClipboardURLProvider and ZeroSuggestProvider.
 // Subsequent matches should decrease in relevance to preserve the ordering
 // in the metadata list.
 static const int kPhysicalWebUrlBaseRelevance = 700;
 
 }
 
 // static
 PhysicalWebProvider* PhysicalWebProvider::Create(
-    AutocompleteProviderClient* client) {
-  return new PhysicalWebProvider(client);
+    AutocompleteProviderClient* client,
+    HistoryURLProvider* history_url_provider) {
+  return new PhysicalWebProvider(client, history_url_provider);
 }
 
 void PhysicalWebProvider::Start(const AutocompleteInput& input,
                                 bool minimal_changes) {
   DCHECK(kPhysicalWebMaxMatches < kMaxMatches);
 
   Stop(false, false);
 
   done_ = false;
   matches_.clear();
 
   // Stop providing suggestions when the user enters text into the omnibox.
   if (!input.from_omnibox_focus()) {
     done_ = true;
     return;
   }
 
   PhysicalWebDataSource* data_source = client_->GetPhysicalWebDataSource();
   if (!data_source) {
     done_ = true;
     return;
   }
 
+  // If the omnibox is not empty, add a default match.
+  // This match will be opened when the user presses "Enter".
+  if (!input.text().empty()) {
+    AutocompleteMatch verbatim_match = VerbatimMatchForURL(
+        client_, input, input.current_url(), history_url_provider_, -1);
+    matches_.push_back(verbatim_match);
+  }
+
   ConstructMatches(data_source->GetMetadata().get());
 
   done_ = true;
 }
 
 void PhysicalWebProvider::Stop(bool clear_cached_results,
                                bool due_to_user_inactivity) {
   done_ = true;
 }
 
-PhysicalWebProvider::PhysicalWebProvider(AutocompleteProviderClient* client)
+PhysicalWebProvider::PhysicalWebProvider(
+    AutocompleteProviderClient* client,
+    HistoryURLProvider* history_url_provider)
     : AutocompleteProvider(AutocompleteProvider::TYPE_PHYSICAL_WEB),
-      client_(client) {
+      client_(client),
+      history_url_provider_(history_url_provider) {
 }
 
 PhysicalWebProvider::~PhysicalWebProvider() {
 }
 
 void PhysicalWebProvider::ConstructMatches(base::ListValue* metadata_list) {
   const size_t metadata_count = metadata_list->GetSize();
+  size_t used_slots = 0;
 
   for (size_t i = 0; i < metadata_count; ++i) {
     base::DictionaryValue* metadata_item = NULL;
     if (!metadata_list->GetDictionary(i, &metadata_item)) {
       continue;
     }
 
     std::string url_string;
     std::string title_string;
     if (!metadata_item->GetString("resolvedUrl", &url_string) ||
         !metadata_item->GetString("title", &title_string)) {
       continue;
     }
 
     // Add match items with decreasing relevance to preserve the ordering in
     // the metadata list.
-    int relevance = kPhysicalWebUrlBaseRelevance - matches_.size();
+    int relevance = kPhysicalWebUrlBaseRelevance - used_slots;
 
     // Append an overflow item if creating a match for each metadata item would
     // exceed the match limit.
-    const size_t remaining_slots = kPhysicalWebMaxMatches - matches_.size();
+    const size_t remaining_slots = kPhysicalWebMaxMatches - used_slots;
     const size_t remaining_metadata = metadata_count - i;
     if ((remaining_slots == 1) && (remaining_metadata > remaining_slots)) {
       AppendOverflowItem(remaining_metadata, relevance);
       return;
     }
 
     GURL url(url_string);
     base::string16 title = base::UTF8ToUTF16(title_string);
 
     AutocompleteMatch match(this, relevance, false,
         AutocompleteMatchType::PHYSICAL_WEB);
     match.destination_url = url;
 
     // Physical Web results should omit http:// (but not https://) and never
     // appear bold.
     match.contents = url_formatter::FormatUrl(url,
         url_formatter::kFormatUrlOmitHTTP, net::UnescapeRule::SPACES,
         nullptr, nullptr, nullptr);
     match.contents_class.push_back(
         ACMatchClassification(0, ACMatchClassification::URL));
 
     match.fill_into_edit =
         AutocompleteInput::FormattedStringWithEquivalentMeaning(
             url, match.contents, client_->GetSchemeClassifier());
 
     match.description = AutocompleteMatch::SanitizeString(title);
     match.description_class.push_back(
         ACMatchClassification(0, ACMatchClassification::NONE));
 
-    match.allowed_to_be_default_match = matches_.empty();
-
     matches_.push_back(match);
+    ++used_slots;
   }
 }
 
 void PhysicalWebProvider::AppendOverflowItem(int additional_url_count,
                                              int relevance) {
   std::string url_string = "chrome://physical-web";
   GURL url(url_string);
 
   AutocompleteMatch match(this, relevance, false,
       AutocompleteMatchType::PHYSICAL_WEB_OVERFLOW);
   match.destination_url = url;
 
   // Don't omit the chrome:// scheme when displaying the WebUI URL.
   match.contents = url_formatter::FormatUrl(url,
       url_formatter::kFormatUrlOmitNothing, net::UnescapeRule::SPACES,
       nullptr, nullptr, nullptr);
   match.contents_class.push_back(
       ACMatchClassification(0, ACMatchClassification::URL));
 
   match.fill_into_edit =
       AutocompleteInput::FormattedStringWithEquivalentMeaning(
           url, match.contents, client_->GetSchemeClassifier());
 
   match.description = l10n_util::GetPluralStringFUTF16(
       IDS_PHYSICAL_WEB_OVERFLOW, additional_url_count);
   match.description_class.push_back(
       ACMatchClassification(0, ACMatchClassification::NONE));
 
-  match.allowed_to_be_default_match = matches_.empty();
-
   matches_.push_back(match);
 }