InstantExtended: Don't create overlay.

chrome/browser/ui/search/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/ui/search/instant_controller.h"
 
 #include <iterator>
 
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
@@ skipping 415 matching lines @@
         }
       } else if (full_text.empty()) {
         // The user is typing, and backspaced away all omnibox text. Clear
         // |last_omnibox_text_| so that we don't attempt to set suggestions.
         last_omnibox_text_.clear();
         last_user_text_.clear();
         last_suggestion_ = InstantSuggestion();
         if (UseTabForSuggestions()) {
           // On a search results page, tell it to clear old results.
           instant_tab_->Update(string16(), 0, 0, true);
-        } else if (search_mode_.is_origin_ntp()) {
+        } else if (overlay_ && search_mode_.is_origin_ntp()) {
           // On the NTP, tell the overlay to clear old results. Don't hide the
           // overlay so it can show a blank page or logo if it wants.
           overlay_->Update(string16(), 0, 0, true);
         } else {
           HideOverlay();
         }
       } else {
         // The user switched to a tab with partial text already in the omnibox.
         HideOverlay();
 
         // The new tab may or may not be a search results page; we don't know
         // since SearchModeChanged() hasn't been called yet. If it later turns
         // out to be, we should store |full_text| now, so that if the user hits
         // Enter, we'll send the correct query to instant_tab_->Submit(). If the
         // partial text is not a query (|last_match_was_search_| is false), we
         // won't Submit(), so no need to worry about that.
         last_user_text_ = user_text;
         last_suggestion_ = InstantSuggestion();
       }
       return false;
     } else if (full_text.empty()) {
       // The user typed a solitary "?". Same as the backspace case above.
       last_omnibox_text_.clear();
       last_user_text_.clear();
       last_suggestion_ = InstantSuggestion();
       if (UseTabForSuggestions())
         instant_tab_->Update(string16(), 0, 0, true);
-      else if (search_mode_.is_origin_ntp())
+      else if (overlay_ && search_mode_.is_origin_ntp())
         overlay_->Update(string16(), 0, 0, true);
       else
         HideOverlay();
       return false;
     }
   } else if (!omnibox_popup_is_open || full_text.empty()) {
     // In the non-extended case, hide the overlay as long as the user isn't
     // actively typing a non-empty query.
     HideOverlay();
     return false;
@@ skipping 35 matching lines @@
   last_transition_type_ = match.transition;
   url_for_history_ = match.destination_url;
 
   // Allow search suggestions. In extended mode, SearchModeChanged() will set
   // this, but it's not called in non-extended mode, so fake it.
   if (!extended_enabled())
     search_mode_.mode = SearchMode::MODE_SEARCH_SUGGESTIONS;
 
   if (UseTabForSuggestions()) {
     instant_tab_->Update(user_text, selection_start, selection_end, verbatim);
-  } else {
+  } else if (overlay_) {
     allow_overlay_to_show_search_suggestions_ = true;
 
     overlay_->Update(extended_enabled() ? user_text : full_text,
                      selection_start, selection_end, verbatim);
   }
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_INSTANT_CONTROLLER_UPDATED,
       content::Source<InstantController>(this),
       content::NotificationService::NoDetails());
@@ skipping 133 matching lines @@
         results.push_back(result);
       }
     }
   }
   LOG_INSTANT_DEBUG_EVENT(this, base::StringPrintf(
       "HandleAutocompleteResults: total_results=%d",
       static_cast<int>(results.size())));
 
   if (UseTabForSuggestions())
     instant_tab_->SendAutocompleteResults(results);
-  else
+  else if (overlay_)
     overlay_->SendAutocompleteResults(results);
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_INSTANT_SENT_AUTOCOMPLETE_RESULTS,
       content::Source<InstantController>(this),
       content::NotificationService::NoDetails());
 }
 
 void InstantController::OnDefaultSearchProviderChanged() {
   if (ntp_ && extended_enabled()) {
@@ skipping 15 matching lines @@
 
 bool InstantController::OnUpOrDownKeyPressed(int count) {
   if (!extended_enabled())
     return false;
 
   if (!UseTabForSuggestions() && !overlay_)
     return false;
 
   if (UseTabForSuggestions())
     instant_tab_->UpOrDownKeyPressed(count);
-  else
+  else if (overlay_)
     overlay_->UpOrDownKeyPressed(count);
 
   return true;
 }
 
 void InstantController::OnCancel(const AutocompleteMatch& match,
                                  const string16& user_text,
                                  const string16& full_text) {
   if (!extended_enabled())
     return;
 
   if (!UseTabForSuggestions() && !overlay_)
     return;
 
   // We manually reset the state here since the JS is not expected to do it.
   // TODO(sreeram): Handle the case where user_text is now a URL
   last_match_was_search_ = AutocompleteMatch::IsSearchType(match.type) &&
                            !full_text.empty();
   last_omnibox_text_ = full_text;
   last_user_text_ = user_text;
   last_suggestion_ = InstantSuggestion();
 
   // Say |full_text| is "amazon.com" and |user_text| is "ama". This means the
   // inline autocompletion is "zon.com"; so the selection should span from
   // user_text.size() to full_text.size(). The selection bounds are inverted
   // because the caret is at the end of |user_text|, not |full_text|.
   if (UseTabForSuggestions()) {
     instant_tab_->CancelSelection(user_text, full_text.size(), user_text.size(),
                                   last_verbatim_);
-  } else {
+  } else if (overlay_) {
     overlay_->CancelSelection(user_text, full_text.size(), user_text.size(),
                               last_verbatim_);
   }
 }
 
 void InstantController::OmniboxNavigateToURL() {
   RecordNavigationHistogram(UsingLocalPage(), false, extended_enabled());
   if (!extended_enabled())
     return;
   if (UseTabForSuggestions())
@@ skipping 92 matching lines @@
          last_suggestion_.behavior == INSTANT_COMPLETE_NEVER)) {
       last_suggestion_.text.clear();
       instant_tab_->Submit(last_omnibox_text_);
       instant_tab_->contents()->GetView()->Focus();
       EnsureSearchTermsAreSet(instant_tab_->contents(), last_omnibox_text_);
       return true;
     }
     return false;
   }
 
+  if (!overlay_)
+    return false;
+
   // If the overlay is not showing at all, don't commit it.
   if (!model_.mode().is_search_suggestions())
     return false;
 
   // If the overlay is showing at full height (with results), commit it.
   // If it's showing at parial height, commit if it's navigating.
   if (!IsOverlayingSearchResults() && type != INSTANT_COMMIT_NAVIGATED)
     return false;
 
   // There may re-entrance here, from the call to browser_->CommitInstant below,
@@ skipping 253 matching lines @@
     return;
 
   // If the overlay is showing or the omnibox has focus, don't refresh the
   // overlay. It will get refreshed the next time the overlay is hidden or the
   // omnibox loses focus.
   if (omnibox_focus_state_ == OMNIBOX_FOCUS_NONE && model_.mode().is_default())
     ResetOverlay(GetInstantURL());
 }
 
 void InstantController::OverlayLoadCompletedMainFrame() {
-  if (overlay_->supports_instant())
+  if (!overlay_ || overlay_->supports_instant())
     return;
   InstantService* instant_service =
       InstantServiceFactory::GetForProfile(browser_->profile());
   content::WebContents* contents = overlay_->contents();
   DCHECK(contents);
   if (instant_service->IsInstantProcess(
       contents->GetRenderProcessHost()->GetID())) {
     return;
   }
   InstantSupportDetermined(contents, false);
@@ skipping 488 matching lines @@
     return false;
 
   // The preloaded NTP does not support instant yet. If we're not in startup,
   // always fall back to the local NTP. If we are in startup, use the local NTP
   // (unless the finch flag to use the remote NTP is set).
   return !(InStartup() && chrome::ShouldPreferRemoteNTPOnStartup());
 }
 
 void InstantController::ResetOverlay(const std::string& instant_url) {
   HideInternal();
-  // If there's no active tab, the browser is opening or closing.
-  const content::WebContents* active_tab = browser_->GetActiveWebContents();
-  if (!active_tab || instant_url.empty()) {
-    overlay_.reset();
-  } else {
-    overlay_.reset(new InstantOverlay(this, instant_url));
-    overlay_->InitContents(browser_->profile(), active_tab);
-  }
-  LOG_INSTANT_DEBUG_EVENT(this, base::StringPrintf(
-      "ResetOverlay: instant_url='%s'", instant_url.c_str()));
+  overlay_.reset();
 }
 
 InstantController::InstantFallbackReason
 InstantController::ShouldSwitchToLocalOverlay() const {
   if (!extended_enabled())
     return INSTANT_FALLBACK_NONE;
 
   if (!overlay())
     return DetermineFallbackReason(NULL, std::string());
 
@@ skipping 71 matching lines @@
 
   // Clear the first interaction timestamp for later use.
   first_interaction_time_ = base::Time();
   first_interaction_time_recorded_ = false;
 
   if (instant_tab_)
     use_tab_for_suggestions_ = true;
 }
 
 void InstantController::ShowOverlay(int height, InstantSizeUnits units) {
+  // Nothing to see here.
+  if (!overlay_)
+    return;
+
   // If we are on a committed search results page, the |overlay_| is not in use.
   if (UseTabForSuggestions())
     return;
 
   LOG_INSTANT_DEBUG_EVENT(this, base::StringPrintf(
       "Show: height=%d units=%d", height, units));
 
   // Must have updated omnibox after the last HideOverlay() to show suggestions.
   if (!allow_overlay_to_show_search_suggestions_)
     return;
@@ skipping 170 matching lines @@
   bool js_webkit_enabled = profile()->GetPrefs()->GetBoolean(
       prefs::kWebKitJavascriptEnabled);
   return js_content_enabled && js_webkit_enabled;
 }
 
 bool InstantController::InStartup() const {
   // TODO(shishir): This is not completely reliable. Find a better way to detect
   // startup time.
   return !browser_->GetActiveWebContents();
 }