Misc. omnibox cleanup:

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 272 matching lines @@
   // 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 gray_text = view_->GetGrayTextAutocompletion();
   const bool visibly_changed_permanent_text =
       (permanent_text_ != new_permanent_text) &&
       (!has_focus() ||
-       (!user_input_in_progress_ &&
-        !(popup_model() && popup_model()->IsOpen()) &&
+       (!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;
   return visibly_changed_permanent_text;
 }
 
 GURL OmniboxEditModel::PermanentURL() {
   return url_formatter::FixupURL(base::UTF16ToUTF8(permanent_text_),
@@ skipping 24 matching lines @@
 }
 
 void OmniboxEditModel::OnChanged() {
   // Hide any suggestions we might be showing.
   view_->SetGrayTextAutocompletion(base::string16());
 
   // Don't call CurrentMatch() when there's no editing, as in this case we'll
   // never actually use it.  This avoids running the autocomplete providers (and
   // any systems they then spin up) during startup.
   const AutocompleteMatch& current_match = user_input_in_progress_ ?
-      CurrentMatch(NULL) : AutocompleteMatch();
+      CurrentMatch(nullptr) : AutocompleteMatch();
 
   client_->OnTextChanged(current_match, user_input_in_progress_, user_text_,
-                         result(), popup_model() && popup_model()->IsOpen(),
-                         has_focus());
+                         result(), PopupIsOpen(), has_focus());
   controller_->OnChanged();
 }
 
 void OmniboxEditModel::GetDataForURLExport(GURL* url,
                                            base::string16* title,
                                            gfx::Image* favicon) {
-  *url = CurrentMatch(NULL).destination_url;
+  *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
   // 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(NULL).type);
+  return !AutocompleteMatch::IsSearchType(CurrentMatch(nullptr).type);
 }
 
 AutocompleteMatch::Type OmniboxEditModel::CurrentTextType() const {
-  return CurrentMatch(NULL).type;
+  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())
     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
   // want to copy what the user actually sees.  However, if we simply never do
-  // this block when !popup_model()->IsOpen(), then just clicking into the
-  // address bar and trying to copy will always bypass this block on pages that
-  // trigger ZeroSuggest, which is too conservative.  Instead, in the
-  // ZeroSuggest case, we check that (a) the user hasn't selected one of the
-  // other suggestions, and (b) the selected text is still the same as the
-  // permanent text.  ((b) probably implies (a), but it doesn't hurt to be
-  // sure.)  If these hold, then it's safe to copy the underlying URL.
+  // this block when !PopupIsOpen(), then just clicking into the address bar and
+  // trying to copy will always bypass this block on pages that trigger
+  // ZeroSuggest, which is too conservative.  Instead, in the ZeroSuggest case,
+  // we check that (a) the user hasn't selected one of the other suggestions,
+  // and (b) the selected text is still the same as the permanent text.  ((b)
+  // probably implies (a), but it doesn't hurt to be sure.)  If these hold, then
+  // it's safe to copy the underlying URL.
   if (!user_input_in_progress_ && is_all_selected &&
-      (!popup_model() || !popup_model()->IsOpen() ||
+      (!PopupIsOpen() ||
        ((popup_model()->selected_line() == 0) && (*text == permanent_text_)))) {
     // It's safe to copy the underlying URL.  These lines ensure that if the
     // scheme was stripped it's added back, and the URL is unescaped (we escape
     // parts of it for display).
     *url = PermanentURL();
     *text = base::UTF8ToUTF16(url->spec());
     *write_url = true;
     return;
   }
 
   // We can't use CurrentTextIsURL() or GetDataForURLExport() because right now
   // the user is probably holding down control to cause the copy, which will
   // screw up our calculation of the desired_tld.
   AutocompleteMatch match;
   client_->GetAutocompleteClassifier()->Classify(
-      *text, is_keyword_selected(), true, ClassifyPage(), &match, NULL);
+      *text, is_keyword_selected(), true, ClassifyPage(), &match, nullptr);
   if (AutocompleteMatch::IsSearchType(match.type))
     return;
   *url = match.destination_url;
 
   // Prefix the text with 'http://' if the text doesn't start with 'http://',
   // the text parses as a url with a scheme of http, the user selected the
   // entire host, and the user hasn't edited the host or manually removed the
   // scheme.
   GURL perm_url(PermanentURL());
   if (perm_url.SchemeIs(url::kHttpScheme) &&
@@ skipping 95 matching lines @@
 
 void OmniboxEditModel::StopAutocomplete() {
   autocomplete_controller()->Stop(true);
 }
 
 bool OmniboxEditModel::CanPasteAndGo(const base::string16& text) const {
   if (!client_->IsPasteAndGoEnabled())
     return false;
 
   AutocompleteMatch match;
-  ClassifyStringForPasteAndGo(text, &match, NULL);
+  ClassifyStringForPasteAndGo(text, &match, nullptr);
   return match.destination_url.is_valid();
 }
 
 void OmniboxEditModel::PasteAndGo(const base::string16& text) {
   DCHECK(CanPasteAndGo(text));
   UMA_HISTOGRAM_COUNTS("Omnibox.PasteAndGo", 1);
 
   view_->RevertAll();
   AutocompleteMatch match;
   GURL alternate_nav_url;
   ClassifyStringForPasteAndGo(text, &match, &alternate_nav_url);
   view_->OpenMatch(match, CURRENT_TAB, alternate_nav_url, text,
                    OmniboxPopupModel::kNoMatch);
 }
 
 bool OmniboxEditModel::IsPasteAndSearch(const base::string16& text) const {
   AutocompleteMatch match;
-  ClassifyStringForPasteAndGo(text, &match, NULL);
+  ClassifyStringForPasteAndGo(text, &match, nullptr);
   return AutocompleteMatch::IsSearchType(match.type);
 }
 
 void OmniboxEditModel::AcceptInput(WindowOpenDisposition disposition,
                                    bool for_drop) {
   // Get the URL and transition type for the selected entry.
   GURL alternate_nav_url;
   AutocompleteMatch match = CurrentMatch(&alternate_nav_url);
 
   // If CTRL is down it means the user wants to append ".com" to the text he
@@ skipping 90 matching lines @@
 
   base::TimeDelta elapsed_time_since_last_change_to_default_match(
       now - autocomplete_controller()->last_time_default_match_changed());
   DCHECK(match.provider);
   // These elapsed times don't really make sense for ZeroSuggest matches
   // (because the user does not modify the omnibox for ZeroSuggest), so for
   // those we set the elapsed times to something that will be ignored by
   // metrics_log.cc.  They also don't necessarily make sense if the omnibox
   // dropdown is closed or the user used a paste-and-go action.  (In most
   // cases when this happens, the user never modified the omnibox.)
+  const bool popup_open = PopupIsOpen();
   if ((match.provider->type() == AutocompleteProvider::TYPE_ZERO_SUGGEST) ||
-      !popup_model()->IsOpen() || !pasted_text.empty()) {
+      !popup_open || !pasted_text.empty()) {
     const base::TimeDelta default_time_delta =
         base::TimeDelta::FromMilliseconds(-1);
     elapsed_time_since_user_first_modified_omnibox = default_time_delta;
     elapsed_time_since_last_change_to_default_match = default_time_delta;
   }
   // If the popup is closed or this is a paste-and-go action (meaning the
   // contents of the dropdown are ignored regardless), we record for logging
   // purposes a selected_index of 0 and a suggestion list as having a single
   // entry of the match used.
+  const bool dropdown_ignored = !popup_open || !pasted_text.empty();
   ACMatches fake_single_entry_matches;
   fake_single_entry_matches.push_back(match);
   AutocompleteResult fake_single_entry_result;
   fake_single_entry_result.AppendMatches(input_, fake_single_entry_matches);
   OmniboxLog log(
       input_.from_omnibox_focus() ? base::string16() : input_text,
       just_deleted_text_,
       input_.type(),
-      popup_model()->IsOpen(),
-      (!popup_model()->IsOpen() || !pasted_text.empty()) ? 0 : index,
+      popup_open,
+      dropdown_ignored ? 0 : index,
       !pasted_text.empty(),
       -1,  // don't yet know tab ID; set later if appropriate
       ClassifyPage(),
       elapsed_time_since_user_first_modified_omnibox,
       match.allowed_to_be_default_match ? match.inline_autocompletion.length() :
           base::string16::npos,
       elapsed_time_since_last_change_to_default_match,
-      (!popup_model()->IsOpen() || !pasted_text.empty()) ?
-          fake_single_entry_result : result());
-  DCHECK(!popup_model()->IsOpen() || !pasted_text.empty() ||
+      dropdown_ignored ? fake_single_entry_result : result());
+  DCHECK(dropdown_ignored ||
          (log.elapsed_time_since_user_first_modified_omnibox >=
           log.elapsed_time_since_last_change_to_default_match))
       << "We should've got the notification that the user modified the "
       << "omnibox text at same time or before the most recent time the "
       << "default match changed.";
 
   if ((disposition == CURRENT_TAB) && client_->CurrentPageExists()) {
     // If we know the destination is being opened in the current tab,
     // we can easily get the tab ID.  (If it's being opened in a new
     // tab, we don't know the tab ID yet.)
@@ skipping 77 matching lines @@
 }
 
 bool OmniboxEditModel::AcceptKeyword(EnteredKeywordModeMethod entered_method) {
   DCHECK(is_keyword_hint_ && !keyword_.empty());
 
   autocomplete_controller()->Stop(false);
   is_keyword_hint_ = false;
 
   user_text_ = MaybeStripKeyword(user_text_);
 
-  if (popup_model() && popup_model()->IsOpen())
+  if (PopupIsOpen())
     popup_model()->SetSelectedLineState(OmniboxPopupModel::KEYWORD);
   else
     StartAutocomplete(false, true, true);
 
   // When entering keyword mode via tab, the new text to show is whatever the
   // newly-selected match in the dropdown is.  When entering via space, however,
   // we should make sure to use the actual |user_text_| as the basis for the new
   // text.  This ensures that if the user types "<keyword><space>" and the
   // default match would have inline autocompleted a further string (e.g.
   // because there's a past multi-word search beginning with this keyword), the
   // inline autocompletion doesn't get filled in as the keyword search query
   // text.
   //
   // We also treat tabbing into keyword mode like tabbing through the popup in
   // that we set |has_temporary_text_|, whereas pressing space is treated like
   // a new keystroke that changes the current match instead of overlaying it
   // with a temporary one.  This is important because rerunning autocomplete
   // after the user pressed space, which will have happened just before reaching
   // here, may have generated a new match, which the user won't actually see and
   // which we don't want to switch back to when existing keyword mode; see
   // comments in ClearKeyword().
   if (entered_method == ENTERED_KEYWORD_MODE_VIA_TAB) {
     // Ensure the current selection is saved before showing keyword mode
     // so that moving to another line and then reverting the text will restore
     // the current state properly.
     bool save_original_selection = !has_temporary_text_;
     has_temporary_text_ = true;
-    const AutocompleteMatch& match = CurrentMatch(NULL);
+    const AutocompleteMatch& match = CurrentMatch(nullptr);
     original_url_ = match.destination_url;
     view_->OnTemporaryTextMaybeChanged(
         MaybeStripKeyword(match.fill_into_edit), save_original_selection,
         true);
   } else {
     view_->OnTemporaryTextMaybeChanged(user_text_, false, true);
   }
 
   base::RecordAction(base::UserMetricsAction("AcceptedKeywordHint"));
   UMA_HISTOGRAM_ENUMERATION(kEnteredKeywordModeHistogram, entered_method,
@@ skipping 140 matching lines @@
 void OmniboxEditModel::OnKillFocus() {
   SetFocusState(OMNIBOX_FOCUS_NONE, OMNIBOX_FOCUS_CHANGE_EXPLICIT);
   focus_source_ = INVALID;
   control_key_state_ = UP;
   paste_state_ = NONE;
 }
 
 bool OmniboxEditModel::WillHandleEscapeKey() const {
   return user_input_in_progress_ ||
       (has_temporary_text_ &&
-       (CurrentMatch(NULL).destination_url != original_url_));
+       (CurrentMatch(nullptr).destination_url != original_url_));
 }
 
 bool OmniboxEditModel::OnEscapeKeyPressed() {
   if (has_temporary_text_ &&
-      (CurrentMatch(NULL).destination_url != original_url_)) {
+      (CurrentMatch(nullptr).destination_url != original_url_)) {
     RevertTemporaryText(true);
     return true;
   }
 
   // We do not clear the pending entry from the omnibox when a load is first
   // stopped.  If the user presses Escape while stopped, whether editing or not,
   // we clear it.
   if (client_->CurrentPageExists() && !client_->IsLoading()) {
     client_->DiscardNonCommittedNavigations();
     view_->Update();
@@ skipping 27 matching lines @@
     control_key_state_ = pressed ? DOWN_WITHOUT_CHANGE : UP;
 }
 
 void OmniboxEditModel::OnPaste() {
   UMA_HISTOGRAM_COUNTS("Omnibox.Paste", 1);
   paste_state_ = PASTING;
 }
 
 void OmniboxEditModel::OnUpOrDownKeyPressed(int count) {
   // NOTE: This purposefully doesn't trigger any code that resets paste_state_.
-  if (popup_model() && popup_model()->IsOpen()) {
+  if (PopupIsOpen()) {
     // The popup is open, so the user should be able to interact with it
     // normally.
     popup_model()->Move(count);
     return;
   }
 
   if (!query_in_progress()) {
     // The popup is neither open nor working on a query already.  So, start an
     // autocomplete query for the current text.  This also sets
     // user_input_in_progress_ to true, which we want: if the user has started
@@ skipping 30 matching lines @@
     if (!keyword_was_selected && is_keyword_selected()) {
       // We just entered keyword mode, so remove the keyword from the input.
       user_text_ = MaybeStripKeyword(user_text_);
     }
 
     // |is_keyword_hint_| should always be false if |keyword_| is empty.
     DCHECK(!keyword_.empty() || !is_keyword_hint_);
   }
 
   // Handle changes to temporary text.
-  if (destination_for_temporary_text_change != NULL) {
+  if (destination_for_temporary_text_change) {
     const bool save_original_selection = !has_temporary_text_;
     if (save_original_selection) {
       // Save the original selection and URL so it can be reverted later.
       has_temporary_text_ = true;
       original_url_ = *destination_for_temporary_text_change;
       inline_autocomplete_text_.clear();
       view_->OnInlineAutocompleteTextCleared();
     }
     if (control_key_state_ == DOWN_WITHOUT_CHANGE) {
       // Arrowing around the popup cancels control-enter.
@@ skipping 34 matching lines @@
     // that case the RevertTemporaryText() call below will reset the caret or
     // selection correctly so the caret positioning we do here won't matter.
     view_->SetWindowTextAndCaretPos(user_text, 0, false, false);
   } else if (view_->OnInlineAutocompleteTextMaybeChanged(
                  user_text + inline_autocomplete_text_, user_text.length())) {
     call_controller_onchanged = false;
   }
 
   // If |has_temporary_text_| is true, then we previously had a manual selection
   // but now don't (or |destination_for_temporary_text_change| would have been
-  // non-NULL). This can happen when deleting the selected item in the popup.
+  // non-null).  This can happen when deleting the selected item in the popup.
   // In this case, we've already reverted the popup to the default match, so we
   // need to revert ourselves as well.
   if (has_temporary_text_) {
     RevertTemporaryText(false);
     call_controller_onchanged = false;
   }
 
   // We need to invoke OnChanged in case the destination url changed (as could
   // happen when control is toggled).
   if (call_controller_onchanged)
@@ skipping 116 matching lines @@
   base::string16 keyword;
   bool is_keyword_hint;
   TemplateURLService* service = client_->GetTemplateURLService();
   match.GetKeywordUIState(service, &keyword, &is_keyword_hint);
   if (popup_model())
     popup_model()->OnResultChanged();
   // OnPopupDataChanged() resets OmniboxController's |current_match_| early
   // on.  Therefore, copy match.inline_autocompletion to a temp to preserve
   // its value across the entire call.
   const base::string16 inline_autocompletion(match.inline_autocompletion);
-  OnPopupDataChanged(inline_autocompletion, NULL, keyword, is_keyword_hint);
+  OnPopupDataChanged(inline_autocompletion, nullptr, keyword, is_keyword_hint);
 }
 
 // static
 const char OmniboxEditModel::kCutOrCopyAllTextHistogram[] =
     "Omnibox.CutOrCopyAllText";
 
-bool OmniboxEditModel::query_in_progress() const {
-  return !autocomplete_controller()->done();
+bool OmniboxEditModel::PopupIsOpen() const {
+  return popup_model() && popup_model()->IsOpen();
 }
 
 void OmniboxEditModel::InternalSetUserText(const base::string16& text) {
   user_text_ = text;
   just_deleted_text_ = false;
   inline_autocomplete_text_.clear();
   view_->OnInlineAutocompleteTextCleared();
 }
 
 void OmniboxEditModel::ClearPopupKeywordMode() const {
   omnibox_controller_->ClearPopupKeywordMode();
 }
 
 base::string16 OmniboxEditModel::MaybeStripKeyword(
     const base::string16& text) const {
   return is_keyword_selected() ?
       KeywordProvider::SplitReplacementStringFromInput(text, false) : text;
 }
 
 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 != NULL);
+  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() ||
-             (popup_model() && popup_model()->IsOpen())) {
+  } else 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 123 matching lines @@
   // 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);
 }