Instant API: tell page whether the browser is capturing key strokes.

chrome/browser/ui/omnibox/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 "chrome/browser/ui/omnibox/omnibox_edit_model.h"
 
 #include <string>
 
 #include "base/format_macros.h"
 #include "base/metrics/histogram.h"
@@ skipping 53 matching lines @@
 using predictors::AutocompleteActionPredictor;
 using predictors::AutocompleteActionPredictorFactory;
 
 ///////////////////////////////////////////////////////////////////////////////
 // OmniboxEditModel::State
 
 OmniboxEditModel::State::State(bool user_input_in_progress,
                                const string16& user_text,
                                const string16& keyword,
                                bool is_keyword_hint,
-                               bool is_caret_visible)
+                               OmniboxFocusState focus_state)
     : user_input_in_progress(user_input_in_progress),
       user_text(user_text),
       keyword(keyword),
       is_keyword_hint(is_keyword_hint),
-      is_caret_visible(is_caret_visible) {
+      focus_state(focus_state) {
 }
 
 OmniboxEditModel::State::~State() {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // OmniboxEditModel
 
 OmniboxEditModel::OmniboxEditModel(OmniboxView* view,
                                    OmniboxEditController* controller,
                                    Profile* profile)
     : view_(view),
       popup_(NULL),
       controller_(controller),
-      has_focus_(false),
-      is_caret_visible_(true),
+      focus_state_(OMNIBOX_FOCUS_NONE),
       user_input_in_progress_(false),
       just_deleted_text_(false),
       has_temporary_text_(false),
       is_temporary_text_set_by_instant_(false),
       paste_state_(NONE),
       control_key_state_(UP),
       is_keyword_hint_(false),
       profile_(profile),
       in_revert_(false),
       allow_exact_keyword_match_(false) {
@@ skipping 19 matching lines @@
     const string16 user_text(UserTextFromDisplayText(view_->GetText()));
     if (user_text.empty()) {
       view_->RevertAll();
       view_->SelectAll(true);
     } else {
       InternalSetUserText(user_text);
     }
   }
 
   return State(user_input_in_progress_, user_text_, keyword_, is_keyword_hint_,
-               is_caret_visible_);
+               focus_state_);
 }
 
 void OmniboxEditModel::RestoreState(const State& state) {
-  SetCaretVisibility(state.is_caret_visible);
+  SetFocusState(state.focus_state, OMNIBOX_FOCUS_CHANGE_TAB_SWITCH);
   // Restore any user editing.
   if (state.user_input_in_progress) {
     // NOTE: Be sure and set keyword-related state BEFORE invoking
     // DisplayTextFromUserText(), as its result depends upon this state.
     keyword_ = state.keyword;
     is_keyword_hint_ = state.is_keyword_hint;
     view_->SetUserText(state.user_text,
         DisplayTextFromUserText(state.user_text), false);
   }
 }
 
 AutocompleteMatch OmniboxEditModel::CurrentMatch() {
   AutocompleteMatch match;
   GetInfoForCurrentText(&match, NULL);
   return match;
 }
 
 bool OmniboxEditModel::UpdatePermanentText(const string16& new_permanent_text) {
   // When there's a new URL, and the user is not editing anything or the edit
   // doesn't have focus, we want to revert the edit to show the new URL.  (The
   // common case where the edit doesn't have focus is when the user has started
   // an edit and then abandoned it and clicked a link on the page.)
   const bool visibly_changed_permanent_text =
       (permanent_text_ != new_permanent_text) &&
-      (!user_input_in_progress_ || !has_focus_);
+      (!user_input_in_progress_ || !has_focus());
 
   permanent_text_ = new_permanent_text;
   return visibly_changed_permanent_text;
 }
 
 GURL OmniboxEditModel::PermanentURL() {
   return URLFixerUpper::FixupURL(UTF16ToUTF8(permanent_text_), std::string());
 }
 
 void OmniboxEditModel::SetUserText(const string16& text) {
@@ skipping 255 matching lines @@
 
 void OmniboxEditModel::Revert() {
   SetInputInProgress(false);
   paste_state_ = NONE;
   InternalSetUserText(string16());
   keyword_.clear();
   is_keyword_hint_ = false;
   has_temporary_text_ = false;
   is_temporary_text_set_by_instant_ = false;
   view_->SetWindowTextAndCaretPos(permanent_text_,
-                                  has_focus_ ? permanent_text_.length() : 0,
+                                  has_focus() ? permanent_text_.length() : 0,
                                   false, true);
   AutocompleteActionPredictor* action_predictor =
       AutocompleteActionPredictorFactory::GetForProfile(profile_);
   if (action_predictor)
     action_predictor->ClearTransitionalMatches();
 }
 
 void OmniboxEditModel::StartAutocomplete(
     bool has_selected_text,
     bool prevent_inline_autocomplete) const {
@@ skipping 255 matching lines @@
     view_->SetWindowTextAndCaretPos(window_text.c_str(), keyword_.length(),
         false, true);
   }
 }
 
 const AutocompleteResult& OmniboxEditModel::result() const {
   return autocomplete_controller_->result();
 }
 
 void OmniboxEditModel::OnSetFocus(bool control_down) {
-  has_focus_ = true;
+  // If the omnibox lost focus while the caret was hidden and then regained
+  // focus, OnSetFocus() is called and should restore visibility. Note that
+  // focus can be regained without an accompanying call to
+  // OmniboxView::SetFocus(), e.g. by tabbing in.
+  SetFocusState(OMNIBOX_FOCUS_VISIBLE, OMNIBOX_FOCUS_CHANGE_EXPLICIT);
   control_key_state_ = control_down ? DOWN_WITHOUT_CHANGE : UP;
-  // Restore caret visibility whenever the user focuses back into the omnibox.
-  SetCaretVisibility(true);
-
-  if (InstantController* instant = controller_->GetInstant())
-    instant->OmniboxGotFocus();
 
   content::WebContents* web_contents = controller_->GetWebContents();
   if (web_contents) {
     // TODO(jered): We may want to merge this into Start() and just call that
     // here rather than having a special entry point for zero-suggest.  Note
     // that we avoid PermanentURL() here because it's not guaranteed to give us
     // the actual underlying current URL, e.g. if we're on the NTP and the
     // |permanent_text_| is empty.
     autocomplete_controller_->StartZeroSuggest(web_contents->GetURL(),
                                                user_text_);
   }
 
   NotifySearchTabHelper();
 }
 
 void OmniboxEditModel::SetCaretVisibility(bool visible) {
-  if (has_focus_ && visible != is_caret_visible_) {
-    is_caret_visible_ = visible;
-    view_->ApplyCaretVisibility();
+  // Caret visibility only matters if the omnibox has focus.
+  if (focus_state_ != OMNIBOX_FOCUS_NONE) {
+    SetFocusState(visible ? OMNIBOX_FOCUS_VISIBLE : OMNIBOX_FOCUS_INVISIBLE,

[Peter Kasting, 2012/12/11 19:20:50]

I wonder if maybe we should just nuke SetCaretVisibility() and make
SetFocusState() public?  Not sure.

[samarth, 2012/12/12 01:11:26]

That seems like overpromising.  We'd have to put a bunch of checks and most of
the state changes would not get honored (e.g. trying to go from NONE to
FOCUS_VISIBLE from some random code).

+                  OMNIBOX_FOCUS_CHANGE_EXPLICIT);
   }
 }
 
 void OmniboxEditModel::OnWillKillFocus(gfx::NativeView view_gaining_focus) {
   SetInstantSuggestion(InstantSuggestion());
 
-  if (InstantController* instant = controller_->GetInstant())
-    instant->OmniboxLostFocus(view_gaining_focus);
+  InstantController* instant = controller_->GetInstant();
+  if (instant) {
+    instant->OmniboxFocusChanged(OMNIBOX_FOCUS_NONE,
+                                 OMNIBOX_FOCUS_CHANGE_EXPLICIT,
+                                 view_gaining_focus);
+  }
 
   // TODO(jered): Rip this out along with StartZeroSuggest.
   autocomplete_controller_->StopZeroSuggest();
   NotifySearchTabHelper();
 }
 
 void OmniboxEditModel::OnKillFocus() {
-  has_focus_ = false;
+  // TODO(samarth): determine if it is safe to move the call to
+  // OmniboxFocusChanged() from OnWillKillFocus() to here, which would let us
+  // just call SetFocusState() to handle the state change.
+  focus_state_ = OMNIBOX_FOCUS_NONE;
   control_key_state_ = UP;
   paste_state_ = NONE;
 }
 
 bool OmniboxEditModel::OnEscapeKeyPressed() {
   if (has_temporary_text_) {
     AutocompleteMatch match;
     InfoForCurrentSelection(&match, NULL);
     if (match.destination_url != original_url_) {
       RevertTemporaryText(true);
@@ skipping 177 matching lines @@
   // that replaced all the text, preserve that information; otherwise, if we've
   // made some other edit, clear paste tracking.
   if (paste_state_ == PASTING)
     paste_state_ = PASTED;
   else if (text_differs)
     paste_state_ = NONE;
 
   // Restore caret visibility whenever the user changes text or selection in the
   // omnibox.
   if (text_differs || selection_differs)
-    SetCaretVisibility(true);
+    SetFocusState(OMNIBOX_FOCUS_VISIBLE, OMNIBOX_FOCUS_CHANGE_TYPING);
 
   // Modifying the selection counts as accepting the autocompleted text.
   const bool user_text_changed =
       text_differs || (selection_differs && !inline_autocomplete_text_.empty());
 
   // If something has changed while the control key is down, prevent
   // "ctrl-enter" until the control key is released.  When we do this, we need
   // to update the popup if it's open, since the desired_tld will have changed.
   if ((text_differs || selection_differs) &&
       (control_key_state_ == DOWN_WITHOUT_CHANGE)) {
@@ skipping 41 matching lines @@
   //
   // If MaybeAcceptKeywordBySpace() accepts the keyword and returns true, that
   // will have updated our state already, so in that case we don't also return
   // true from this function.
   return !(text_differs && allow_keyword_ui_change && !just_deleted_text &&
            no_selection && (selection_start == user_text_.length()) &&
            MaybeAcceptKeywordBySpace(user_text_));
 }
 
 void OmniboxEditModel::PopupBoundsChangedTo(const gfx::Rect& bounds) {
-  if (InstantController* instant = controller_->GetInstant())
+  InstantController* instant = controller_->GetInstant();
+  if (instant)
     instant->SetOmniboxBounds(bounds);
 }
 
 void OmniboxEditModel::OnResultChanged(bool default_match_changed) {
   const bool was_open = popup_->IsOpen();
   if (default_match_changed) {
     string16 inline_autocomplete_text;
     string16 keyword;
     bool is_keyword_hint = false;
     const AutocompleteResult& result = this->result();
@@ skipping 28 matching lines @@
   } else if (was_open) {
     // Accepts the temporary text as the user text, because it makes little
     // sense to have temporary text when the popup is closed.
     InternalSetUserText(UserTextFromDisplayText(view_->GetText()));
     has_temporary_text_ = false;
     is_temporary_text_set_by_instant_ = false;
     PopupBoundsChangedTo(gfx::Rect());
     NotifySearchTabHelper();
   }
 
-  if (InstantController* instant = controller_->GetInstant())
+  InstantController* instant = controller_->GetInstant();
+  if (instant)
     instant->HandleAutocompleteResults(*autocomplete_controller_->providers());
 }
 
 bool OmniboxEditModel::query_in_progress() const {
   return !autocomplete_controller_->done();
 }
 
 void OmniboxEditModel::InternalSetUserText(const string16& text) {
   user_text_ = text;
   just_deleted_text_ = false;
@@ skipping 204 matching lines @@
 }
 
 void OmniboxEditModel::ClassifyStringForPasteAndGo(
     const string16& text,
     AutocompleteMatch* match,
     GURL* alternate_nav_url) const {
   DCHECK(match);
   AutocompleteClassifierFactory::GetForProfile(profile_)->Classify(text,
       string16(), false, false, match, alternate_nav_url);
 }
+
+void OmniboxEditModel::SetFocusState(OmniboxFocusState state,
+                                     OmniboxFocusChangeReason reason) {
+  if (state == focus_state_)
+    return;
+
+  InstantController* instant = controller_->GetInstant();
+  if (instant)
+    instant->OmniboxFocusChanged(state, reason, NULL);
+
+  // 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();
+}