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

chrome/browser/instant/instant_controller.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/instant/instant_controller.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 134 matching lines @@
 InstantController::InstantController(chrome::BrowserInstantController* browser,
                                      bool extended_enabled)
     : browser_(browser),
       extended_enabled_(extended_enabled),
       instant_enabled_(false),
       model_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       last_omnibox_text_has_inline_autocompletion_(false),
       last_verbatim_(false),
       last_transition_type_(content::PAGE_TRANSITION_LINK),
       last_match_was_search_(false),
-      is_omnibox_focused_(false),
+      omnibox_focus_state_(FOCUS_NONE),
       allow_preview_to_show_search_suggestions_(false) {
 }
 
 InstantController::~InstantController() {
 }
 
 bool InstantController::Update(const AutocompleteMatch& match,
                                const string16& user_text,
                                const string16& full_text,
                                size_t selection_start,
@@ skipping 360 matching lines @@
   // Delay deletion as we could've gotten here from an InstantLoader method.
   MessageLoop::current()->DeleteSoon(FROM_HERE, loader_.release());
 
   // Try to create another loader immediately so that it is ready for the next
   // user interaction.
   CreateDefaultLoader();
 
   return true;
 }
 
-void InstantController::OmniboxLostFocus(gfx::NativeView view_gaining_focus) {
-  DVLOG(1) << "OmniboxLostFocus";
-  is_omnibox_focused_ = false;
+void InstantController::OmniboxFocusChanged(
+    OmniboxFocusState state,
+    OmniboxFocusChangeReason reason,
+    gfx::NativeView view_gaining_focus) {
+  DVLOG(1) << "OmniboxFocusChanged: " << omnibox_focus_state_ << " to "
+           << state << " for reason " << reason;
 
+  OmniboxFocusState old_focus_state = omnibox_focus_state_;
+  omnibox_focus_state_ = state;
   if (!extended_enabled_ && !instant_enabled_)
     return;
 
-  // If the preview isn't showing search suggestions, nothing to do. The check
-  // for GetPreviewContents() (which normally is redundant, given IsCurrent())
-  // is to handle the case when we get here during a commit.
-  if (!IsCurrent() || !GetPreviewContents()) {
-    OnStaleLoader();
-    return;
-  }
+  // Tell the page if the key capture mode changed unless the focus state
+  // changed because of TYPING. This is because in that case, the browser hasn't
+  // really stopped capturing key strokes.
+  //
+  // (More practically, if we don't do this check, the page would receieve
+  // keycapturechange before the corresponding onchange, and the page would have
+  // no way of telling whether the keycapturechange happened because of some
+  // actual user action or just because they started typing.)
+  if (extended_enabled_ && GetPreviewContents() &&
+      reason != FOCUS_CHANGE_TYPING)
+    loader_->KeyCaptureChanged(omnibox_focus_state_ == FOCUS_INVISIBLE);
 
-#if defined(OS_MACOSX)
-  if (!loader_->is_pointer_down_from_activate())
-    HideLoader();
-#else
-  if (IsViewInContents(GetViewGainingFocus(view_gaining_focus),
-                       loader_->contents()))
-    CommitIfCurrent(INSTANT_COMMIT_FOCUS_LOST);
-  else
-    HideLoader();
-#endif
-}
-
-void InstantController::OmniboxGotFocus() {
-  DVLOG(1) << "OmniboxGotFocus";
-  is_omnibox_focused_ = true;
-
-  if (!extended_enabled_ && !instant_enabled_)
-    return;
-
-  CreateDefaultLoader();
+  // If focus went from outside the omnibox to the omnibox, preload the default
+  // search engine, in anticipation of the user typing a query. If the reverse
+  // happened, commit or discard the preview.
+  if (state != FOCUS_NONE && old_focus_state == FOCUS_NONE)
+    CreateDefaultLoader();
+  else if (state == FOCUS_NONE && old_focus_state != FOCUS_NONE)
+    OmniboxLostFocus(view_gaining_focus);
 }
 
 void InstantController::SearchModeChanged(
     const chrome::search::Mode& old_mode,
     const chrome::search::Mode& new_mode) {
   if (!extended_enabled_)
     return;
 
   DVLOG(1) << "SearchModeChanged: [origin:mode] " << old_mode.origin << ":"
            << old_mode.mode << " to " << new_mode.origin << ":"
@@ skipping 178 matching lines @@
 
 void InstantController::InstantLoaderContentsFocused() {
 #if defined(USE_AURA)
   // On aura the omnibox only receives a focus lost if we initiate the focus
   // change. This does that.
   if (!model_.mode().is_default())
     browser_->InstantPreviewFocused();
 #endif
 }
 
+void InstantController::OmniboxLostFocus(gfx::NativeView view_gaining_focus) {
+  DVLOG(1) << "OmniboxLostFocus";
+  // If the preview isn't showing search suggestions, nothing to do. The check
+  // for GetPreviewContents() (which normally is redundant, given IsCurrent())
+  // is to handle the case when we get here during a commit.
+  if (!IsCurrent() || !GetPreviewContents()) {
+    OnStaleLoader();
+    return;
+  }
+
+#if defined(OS_MACOSX)
+  if (!loader_->is_pointer_down_from_activate())
+    HideLoader();
+#else
+  if (IsViewInContents(GetViewGainingFocus(view_gaining_focus),
+                       loader_->contents()))
+    CommitIfCurrent(INSTANT_COMMIT_FOCUS_LOST);
+  else
+    HideLoader();
+#endif
+}
+
 bool InstantController::ResetLoader(const TemplateURL* template_url,
                                     const content::WebContents* active_tab) {
   std::string instant_url;
   if (!GetInstantURL(template_url, &instant_url))
     return false;
 
   if (loader_ && loader_->instant_url() == instant_url)
     return true;
 
   HideInternal();
   loader_.reset(new InstantLoader(this, instant_url));
   loader_->InitContents(active_tab);
 
   // Ensure the searchbox API has the correct initial state.
   if (extended_enabled_) {
     browser_->UpdateThemeInfoForPreview();
     loader_->SetDisplayInstantResults(instant_enabled_);
     loader_->SearchModeChanged(search_mode_);
+    loader_->KeyCaptureChanged(omnibox_focus_state_ == FOCUS_INVISIBLE);
   }
 
   // Restart the stale loader timer.
   stale_loader_timer_.Start(FROM_HERE,
       base::TimeDelta::FromMilliseconds(kStaleLoaderTimeoutMS), this,
       &InstantController::OnStaleLoader);
 
   return true;
 }
 
 bool InstantController::CreateDefaultLoader() {
   // If there's no active tab, the browser is closing.
   const content::WebContents* active_tab = browser_->GetActiveWebContents();
   if (!active_tab)
     return false;
 
   const TemplateURL* template_url = TemplateURLServiceFactory::GetForProfile(
       Profile::FromBrowserContext(active_tab->GetBrowserContext()))->
       GetDefaultSearchProvider();
 
   return ResetLoader(template_url, active_tab);
 }
 
 void InstantController::OnStaleLoader() {
   // If the preview is showing or the omnibox has focus, don't delete the
   // loader. It will get refreshed the next time the preview is hidden or the
   // omnibox loses focus.
-  if (!stale_loader_timer_.IsRunning() && !is_omnibox_focused_ &&
+  if (!stale_loader_timer_.IsRunning() && omnibox_focus_state_ == FOCUS_NONE &&
       model_.mode().is_default()) {
     loader_.reset();
     CreateDefaultLoader();
   }
 }
 
 void InstantController::ResetInstantTab() {
   if (search_mode_.is_origin_search()) {
     content::WebContents* active_tab = browser_->GetActiveWebContents();
     if (!instant_tab_ || active_tab != instant_tab_->contents()) {
@@ skipping 180 matching lines @@
   }
 
   std::map<std::string, int>::const_iterator iter =
       blacklisted_urls_.find(*instant_url);
   if (iter != blacklisted_urls_.end() &&
       iter->second > kMaxInstantSupportFailures)
     return false;
 
   return true;
 }