Remove search::GetSearchTerms since it always returns empty string

components/omnibox/browser/omnibox_edit_model.cc

 // Copyright 2012 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 "components/omnibox/browser/omnibox_edit_model.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 71 matching lines @@
 // between focusing and opening an omnibox match.
 const char kFocusToOpenTimeHistogram[] =
     "Omnibox.FocusToOpenTimeAnyPopupState2";
 
 // Split the percentage match histograms into buckets based on the width of the
 // omnibox.
 const int kPercentageMatchHistogramWidthBuckets[] = { 400, 700, 1200 };
 
 void RecordPercentageMatchHistogram(const base::string16& old_text,
                                     const base::string16& new_text,
-                                    bool url_replacement_active,
                                     ui::PageTransition transition,
                                     int omnibox_width) {
   size_t avg_length = (old_text.length() + new_text.length()) / 2;
 
   int percent = 0;
   if (!old_text.empty() && !new_text.empty()) {
     size_t shorter_length = std::min(old_text.length(), new_text.length());
     base::string16::const_iterator end(old_text.begin() + shorter_length);
     base::string16::const_iterator mismatch(
         std::mismatch(old_text.begin(), end, new_text.begin()).first);
     size_t matching_characters = mismatch - old_text.begin();
     percent = static_cast<float>(matching_characters) / avg_length * 100;
   }
 
+  // TODO(treib,mpearson): Do we want to keep these histograms? Most of the
+  // previously-logged cases don't exist anymore. crbug.com/627747
   std::string histogram_name;
-  if (url_replacement_active) {
-    if (ui::PageTransitionTypeIncludingQualifiersIs(
-            transition, ui::PAGE_TRANSITION_TYPED)) {
-      histogram_name = "InstantExtended.PercentageMatchV2_QuerytoURL";
-      UMA_HISTOGRAM_PERCENTAGE(histogram_name, percent);
-    } else {
-      histogram_name = "InstantExtended.PercentageMatchV2_QuerytoQuery";
-      UMA_HISTOGRAM_PERCENTAGE(histogram_name, percent);
-    }
+  if (ui::PageTransitionTypeIncludingQualifiersIs(
+          transition, ui::PAGE_TRANSITION_TYPED)) {
+    histogram_name = "InstantExtended.PercentageMatchV2_URLtoURL";
+    UMA_HISTOGRAM_PERCENTAGE(histogram_name, percent);
   } else {
-    if (ui::PageTransitionTypeIncludingQualifiersIs(
-            transition, ui::PAGE_TRANSITION_TYPED)) {
-      histogram_name = "InstantExtended.PercentageMatchV2_URLtoURL";
-      UMA_HISTOGRAM_PERCENTAGE(histogram_name, percent);
-    } else {
-      histogram_name = "InstantExtended.PercentageMatchV2_URLtoQuery";
-      UMA_HISTOGRAM_PERCENTAGE(histogram_name, percent);
-    }
+    histogram_name = "InstantExtended.PercentageMatchV2_URLtoQuery";
+    UMA_HISTOGRAM_PERCENTAGE(histogram_name, percent);
   }
 
   std::string suffix = "large";
   for (size_t i = 0; i < arraysize(kPercentageMatchHistogramWidthBuckets);
        ++i) {
     if (omnibox_width < kPercentageMatchHistogramWidthBuckets[i]) {
       suffix = base::IntToString(kPercentageMatchHistogramWidthBuckets[i]);
       break;
     }
   }
@@ skipping 90 matching lines @@
       controller_->GetToolbarModel()->url_replacement_enabled(),
       focus_state_, focus_source_, input_);
 }
 
 void OmniboxEditModel::RestoreState(const State* state) {
   // We need to update the permanent text correctly and revert the view
   // regardless of whether there is saved state.
   bool url_replacement_enabled = !state || state->url_replacement_enabled;
   controller_->GetToolbarModel()->set_url_replacement_enabled(
       url_replacement_enabled);
-  permanent_text_ = controller_->GetToolbarModel()->GetText();
+  permanent_text_ = controller_->GetToolbarModel()->GetFormattedURL(nullptr);
   // Don't muck with the search term replacement state, as we've just set it
   // correctly.
   view_->RevertWithoutResettingSearchTermReplacement();
   // Restore the autocomplete controller's input, or clear it if this is a new
   // tab.
   input_ = state ? state->autocomplete_input : AutocompleteInput();
   if (!state)
     return;
 
   SetFocusState(state->focus_state, OMNIBOX_FOCUS_CHANGE_TAB_SWITCH);
@@ skipping 37 matching lines @@
   // always safe to change the text; this also prevents someone toggling "Show
   // URL" (which sounds as if it might be persistent) from seeing just that URL
   // forever afterwards.
   //
   // If the page is auto-committing gray text, however, we generally don't want
   // to make any change to the edit.  While auto-commits modify the underlying
   // permanent URL, they're intended to have no effect on the user's editing
   // process -- before and after the auto-commit, the omnibox should show the
   // same user text and the same instant suggestion, even if the auto-commit
   // happens while the edit doesn't have focus.
-  base::string16 new_permanent_text = controller_->GetToolbarModel()->GetText();
+  base::string16 new_permanent_text =
+      controller_->GetToolbarModel()->GetFormattedURL(nullptr);
   base::string16 gray_text = view_->GetGrayTextAutocompletion();
   const bool visibly_changed_permanent_text =
       (permanent_text_ != new_permanent_text) &&
       (!has_focus() ||
        (!user_input_in_progress_ && !PopupIsOpen() &&
         controller_->GetToolbarModel()->url_replacement_enabled())) &&
       (gray_text.empty() ||
        new_permanent_text != user_text_ + gray_text);
 
   permanent_text_ = new_permanent_text;
@@ skipping 47 matching lines @@
                                            base::string16* title,
                                            gfx::Image* favicon) {
   *url = CurrentMatch(nullptr).destination_url;
   if (*url == client_->GetURL()) {
     *title = client_->GetTitle();
     *favicon = client_->GetFavicon();
   }
 }
 
 bool OmniboxEditModel::CurrentTextIsURL() const {
-  if (controller_->GetToolbarModel()->WouldReplaceURL())
-    return false;
-
-  // If current text is not composed of replaced search terms and
-  // !user_input_in_progress_, then permanent text is showing and should be a
+  // If !user_input_in_progress_, then permanent text is showing and should be a
   // URL, so no further checking is needed.  By avoiding checking in this case,
   // we avoid calling into the autocomplete providers, and thus initializing the
   // history system, as long as possible, which speeds startup.
   if (!user_input_in_progress_)
     return true;
 
   return !AutocompleteMatch::IsSearchType(CurrentMatch(nullptr).type);
 }
 
 AutocompleteMatch::Type OmniboxEditModel::CurrentTextType() const {
   return CurrentMatch(nullptr).type;
 }
 
 void OmniboxEditModel::AdjustTextForCopy(int sel_min,
                                          bool is_all_selected,
                                          base::string16* text,
                                          GURL* url,
                                          bool* write_url) {
   *write_url = false;
 
-  // Do not adjust if selection did not start at the beginning of the field, or
-  // if the URL was omitted.
-  if ((sel_min != 0) || controller_->GetToolbarModel()->WouldReplaceURL())
+  // Do not adjust if selection did not start at the beginning of the field.
+  if (sel_min != 0)
     return;
 
   // Check whether the user is trying to copy the current page's URL by
   // selecting the whole thing without editing it.
   //
   // This is complicated by ZeroSuggest.  When ZeroSuggest is active, the user
   // may be selecting different items and thus changing the address bar text,
   // even though !user_input_in_progress_; and the permanent URL may change
   // without updating the visible text, just like when user input is in
   // progress.  In these cases, we don't want to copy the underlying URL, we
@@ skipping 373 matching lines @@
 
   // Get the current text before we call RevertAll() which will clear it.
   base::string16 current_text = view_->GetText();
 
   if (disposition != NEW_BACKGROUND_TAB) {
     base::AutoReset<bool> tmp(&in_revert_, true);
     view_->RevertAll();  // Revert the box to its unedited state.
   }
 
   RecordPercentageMatchHistogram(
-      permanent_text_, current_text,
-      controller_->GetToolbarModel()->WouldReplaceURL(),
-      match.transition, view_->GetWidth());
+      permanent_text_, current_text, match.transition, view_->GetWidth());
 
   // Track whether the destination URL sends us to a search results page
   // using the default search provider.
   TemplateURLService* template_url_service = client_->GetTemplateURLService();
   if (template_url_service &&
       template_url_service->IsSearchResultsPageFromDefaultSearchProvider(
           match.destination_url)) {
     base::RecordAction(
         base::UserMetricsAction("OmniboxDestinationURLIsSearchOnDSP"));
   }
@@ skipping 581 matching lines @@
 
 base::string16 OmniboxEditModel::MaybePrependKeyword(
     const base::string16& text) const {
   return is_keyword_selected() ? (keyword_ + base::char16(' ') + text) : text;
 }
 
 void OmniboxEditModel::GetInfoForCurrentText(AutocompleteMatch* match,
                                              GURL* alternate_nav_url) const {
   DCHECK(match);
 
-  if (controller_->GetToolbarModel()->WouldPerformSearchTermReplacement(
-      false)) {
-    // Any time the user hits enter on the unchanged omnibox, we should reload.
-    // When we're not extracting search terms, AcceptInput() will take care of
-    // this (see code referring to PAGE_TRANSITION_RELOAD there), but when we're
-    // extracting search terms, the conditionals there won't fire, so we
-    // explicitly set up a match that will reload here.
-
-    // It's important that we fetch the current visible URL to reload instead of
-    // just getting a "search what you typed" URL from
-    // SearchProvider::CreateSearchSuggestion(), since the user may be in a
-    // non-default search mode such as image search.
-    match->type = AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED;
-    match->provider = autocomplete_controller()->search_provider();
-    match->destination_url = client_->GetURL();
-    match->transition = ui::PAGE_TRANSITION_RELOAD;
-  } else if (query_in_progress() || PopupIsOpen()) {
+  if (query_in_progress() || PopupIsOpen()) {
     if (query_in_progress()) {
       // It's technically possible for |result| to be empty if no provider
       // returns a synchronous result but the query has not completed
       // synchronously; pratically, however, that should never actually happen.
       if (result().empty())
         return;
       // The user cannot have manually selected a match, or the query would have
       // stopped. So the default match must be the desired selection.
       *match = *result().default_match();
     } else {
@@ skipping 91 matching lines @@
   const GURL& gurl = client_->GetURL();
   if (!gurl.is_valid())
     return OmniboxEventProto::INVALID_SPEC;
   const std::string& url = gurl.spec();
   if (client_->IsNewTabPage(url))
     return OmniboxEventProto::NTP;
   if (url == url::kAboutBlankURL)
     return OmniboxEventProto::BLANK;
   if (client_->IsHomePage(url))
     return OmniboxEventProto::HOME_PAGE;
-  if (controller_->GetToolbarModel()->WouldPerformSearchTermReplacement(true))
-    return OmniboxEventProto::SEARCH_RESULT_PAGE_DOING_SEARCH_TERM_REPLACEMENT;
   if (client_->IsSearchResultsPage())
     return OmniboxEventProto::SEARCH_RESULT_PAGE_NO_SEARCH_TERM_REPLACEMENT;
   return OmniboxEventProto::OTHER;
 }
 
 void OmniboxEditModel::ClassifyStringForPasteAndGo(
     const base::string16& text,
     AutocompleteMatch* match,
     GURL* alternate_nav_url) const {
   DCHECK(match);
   client_->GetAutocompleteClassifier()->Classify(
       text, false, false, ClassifyPage(), match, alternate_nav_url);
 }
 
 void OmniboxEditModel::SetFocusState(OmniboxFocusState state,
                                      OmniboxFocusChangeReason reason) {
   if (state == focus_state_)
     return;
 
   // Update state and notify view if the omnibox has focus and the caret
   // visibility changed.
   const bool was_caret_visible = is_caret_visible();
   focus_state_ = state;
   if (focus_state_ != OMNIBOX_FOCUS_NONE &&
       is_caret_visible() != was_caret_visible)
     view_->ApplyCaretVisibility();
 
   client_->OnFocusChanged(focus_state_, reason);
 }