InstantExtended: hook up InstantTab in incognito.

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 321 matching lines @@
   last_omnibox_text_ = full_text;
   last_match_was_search_ = AutocompleteMatch::IsSearchType(match.type) &&
                            !user_text.empty();
 
   // TODO(dhollowa): Complete keyword match UI.  For now just hide suggestions.
   // http://crbug.com/153932.  Note, this early escape is happens prior to the
   // DCHECKs below because |user_text| and |full_text| have different semantics
   // when keyword search is in effect.
   if (is_keyword_search) {
     if (UseTabForSuggestions())
-      instant_tab_->Update(string16(), 0, 0, true);
+      instant_tab_->sender()->Update(string16(), 0, 0, true);
     else
       HideOverlay();
     last_match_was_search_ = false;
     last_suggestion_ = InstantSuggestion();
     return false;
   }
 
   // Ignore spurious updates when the omnibox is blurred; otherwise click
   // targets on the page may vanish before a click event arrives.
   if (omnibox_focus_state_ == OMNIBOX_FOCUS_NONE)
@@ skipping 53 matching lines @@
           // be pointing to the previous tab (which was a search results page).
           // Ensure we don't send the omnibox text to a random webpage (the new
           // tab), by comparing the old and new WebContents.
           if (escape_pressed &&
               instant_tab_->contents() == browser_->GetActiveWebContents()) {
             // TODO(kmadhusu): If the |full_text| is not empty, send an
             // onkeypress(esc) to the Instant page. Do not call
             // onsubmit(full_text). Fix.
             if (full_text.empty()) {
               // Call onchange("") to clear the query for the page.
-              instant_tab_->Update(string16(), 0, 0, true);
-              instant_tab_->EscKeyPressed();
+              instant_tab_->sender()->Update(string16(), 0, 0, true);
+              instant_tab_->sender()->EscKeyPressed();
              } else {
-              instant_tab_->Submit(full_text);
+              instant_tab_->sender()->Submit(full_text);
             }
           }
         } else if (!full_text.empty()) {
           // If |full_text| is empty, the user is on the NTP. The overlay may
           // be showing custom NTP content; hide only if that's not the case.
           HideOverlay();
         }
       } 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);
+          instant_tab_->sender()->Update(string16(), 0, 0, true);
         } 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.
+        // Enter, we'll send the correct query to
+        // instant_tab_->sender()->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);
+        instant_tab_->sender()->Update(string16(), 0, 0, true);
       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();
@@ 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);
+    instant_tab_->sender()->Update(user_text, selection_start,
+                                   selection_end, verbatim);
   } 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),
@@ skipping 58 matching lines @@
         &InstantController::SendPopupBoundsToPage);
   }
 }
 
 void InstantController::SetOmniboxBounds(const gfx::Rect& bounds) {
   if (!extended_enabled() || omnibox_bounds_ == bounds)
     return;
 
   omnibox_bounds_ = bounds;
   if (overlay_)
-    overlay_->SetOmniboxBounds(omnibox_bounds_);
+    overlay_->sender()->SetOmniboxBounds(omnibox_bounds_);
   if (ntp_)
-    ntp_->SetOmniboxBounds(omnibox_bounds_);
+    ntp_->sender()->SetOmniboxBounds(omnibox_bounds_);
   if (instant_tab_)
-    instant_tab_->SetOmniboxBounds(omnibox_bounds_);
+    instant_tab_->sender()->SetOmniboxBounds(omnibox_bounds_);
 }
 
 void InstantController::HandleAutocompleteResults(
     const std::vector<AutocompleteProvider*>& providers,
     const AutocompleteResult& autocomplete_result) {
   if (!extended_enabled())
     return;
 
   if (!UseTabForSuggestions() && !overlay_)
     return;
@@ skipping 50 matching lines @@
                                                    &result);
         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);
+    instant_tab_->sender()->SendAutocompleteResults(results);
   else if (overlay_)
-    overlay_->SendAutocompleteResults(results);
+    overlay_->sender()->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()) {
     ntp_.reset();
@@ skipping 13 matching lines @@
 }
 
 bool InstantController::OnUpOrDownKeyPressed(int count) {
   if (!extended_enabled())
     return false;
 
   if (!UseTabForSuggestions() && !overlay_)
     return false;
 
   if (UseTabForSuggestions())
-    instant_tab_->UpOrDownKeyPressed(count);
+    instant_tab_->sender()->UpOrDownKeyPressed(count);
   else if (overlay_)
-    overlay_->UpOrDownKeyPressed(count);
+    overlay_->sender()->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_);
+    instant_tab_->sender()->CancelSelection(user_text, full_text.size(),
+                                            user_text.size(), last_verbatim_);
   } else if (overlay_) {
-    overlay_->CancelSelection(user_text, full_text.size(), user_text.size(),
-                              last_verbatim_);
+    overlay_->sender()->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())
-    instant_tab_->Submit(string16());
+    instant_tab_->sender()->Submit(string16());
 }
 
 void InstantController::ToggleVoiceSearch() {
   if (instant_tab_)
-    instant_tab_->ToggleVoiceSearch();
+    instant_tab_->sender()->ToggleVoiceSearch();
 }
 
 void InstantController::InstantPageLoadFailed(content::WebContents* contents) {
   if (!chrome::ShouldPreferRemoteNTPOnStartup() || !extended_enabled()) {
     // We only need to fall back on errors if we're showing the online page
     // at startup, as otherwise we fall back correctly when trying to show
     // a page that hasn't yet indicated that it supports the InstantExtended
     // API.
     return;
   }
@@ skipping 42 matching lines @@
   return model_.mode().is_search_suggestions() && IsFullHeight(model_) &&
          (last_match_was_search_ ||
           last_suggestion_.behavior == INSTANT_COMPLETE_NEVER);
 }
 
 bool InstantController::SubmitQuery(const string16& search_terms) {
   if (extended_enabled() && instant_tab_ && instant_tab_->supports_instant() &&
       search_mode_.is_origin_search()) {
     // Use |instant_tab_| to run the query if we're already on a search results
     // page. (NOTE: in particular, we do not send the query to NTPs.)
-    instant_tab_->Submit(search_terms);
+    instant_tab_->sender()->Submit(search_terms);
     instant_tab_->contents()->GetView()->Focus();
     EnsureSearchTermsAreSet(instant_tab_->contents(), search_terms);
     return true;
   }
   return false;
 }
 
 bool InstantController::CommitIfPossible(InstantCommitType type) {
   if (!extended_enabled() && !instant_enabled_)
     return false;
 
   LOG_INSTANT_DEBUG_EVENT(this, base::StringPrintf(
       "CommitIfPossible: type=%d last_omnibox_text_='%s' "
       "last_match_was_search_=%d use_tab_for_suggestions=%d", type,
       UTF16ToUTF8(last_omnibox_text_).c_str(), last_match_was_search_,
       UseTabForSuggestions()));
 
   // If we are on an already committed search results page, send a submit event
   // to the page, but otherwise, nothing else to do.
   if (UseTabForSuggestions()) {
     if (type == INSTANT_COMMIT_PRESSED_ENTER &&
         !instant_tab_->IsLocal() &&
         (last_match_was_search_ ||
          last_suggestion_.behavior == INSTANT_COMPLETE_NEVER)) {
       last_suggestion_.text.clear();
-      instant_tab_->Submit(last_omnibox_text_);
+      instant_tab_->sender()->Submit(last_omnibox_text_);
       instant_tab_->contents()->GetView()->Focus();
       EnsureSearchTermsAreSet(instant_tab_->contents(), last_omnibox_text_);
       return true;
     }
     return false;
   }
 
   if (!overlay_)
     return false;
 
@@ skipping 12 matching lines @@
   if (!GetOverlayContents())
     return false;
 
   // Never commit the local overlay.
   if (overlay_->IsLocal())
     return false;
 
   if (type == INSTANT_COMMIT_FOCUS_LOST) {
     // Extended mode doesn't need or use the Cancel message.
     if (!extended_enabled())
-      overlay_->Cancel(last_omnibox_text_);
+      overlay_->sender()->Cancel(last_omnibox_text_);
   } else if (type != INSTANT_COMMIT_NAVIGATED) {
-    overlay_->Submit(last_omnibox_text_);
+    overlay_->sender()->Submit(last_omnibox_text_);
   }
 
   // We expect the WebContents to be in a valid state (i.e., has a last
   // committed entry, no transient entry, and no existing pending entry).
   scoped_ptr<content::WebContents> overlay = overlay_->ReleaseContents();
   CHECK(overlay->GetController().CanPruneAllButVisible());
 
   // If the overlay page has navigated since the last Update(), we need to add
   // the navigation to history ourselves. Else, the page will navigate after
   // commit, and it will be added to history in the usual manner.
@@ skipping 91 matching lines @@
       "OmniboxFocusChanged: %d to %d for reason %d", omnibox_focus_state_,
       state, reason));
 
   OmniboxFocusState old_focus_state = omnibox_focus_state_;
   omnibox_focus_state_ = state;
   if (!extended_enabled() && !instant_enabled_)
     return;
 
   if (extended_enabled()) {
     if (overlay_)
-      overlay_->FocusChanged(omnibox_focus_state_, reason);
+      overlay_->sender()->FocusChanged(omnibox_focus_state_, reason);
 
     if (instant_tab_) {
-      instant_tab_->FocusChanged(omnibox_focus_state_, reason);
+      instant_tab_->sender()->FocusChanged(omnibox_focus_state_, reason);
       // Don't send oninputstart/oninputend updates in response to focus changes
       // if there's a navigation in progress. This prevents Chrome from sending
       // a spurious oninputend when the user accepts a match in the omnibox.
       if (instant_tab_->contents()->GetController().GetPendingEntry() == NULL)
-        instant_tab_->SetInputInProgress(IsInputInProgress());
+        instant_tab_->sender()->SetInputInProgress(IsInputInProgress());
     }
   }
 
   if (state == OMNIBOX_FOCUS_VISIBLE && old_focus_state == OMNIBOX_FOCUS_NONE) {
     // If the user explicitly focused the omnibox, then create the overlay if
     // it doesn't exist. If we're using a fallback overlay, try loading the
     // remote overlay again.
     if (!overlay_ || (overlay_->IsLocal() && !use_local_page_only_))
       ResetOverlay(GetInstantURL());
   } else if (state == OMNIBOX_FOCUS_NONE &&
@@ skipping 13 matching lines @@
       "SearchModeChanged: [origin:mode] %d:%d to %d:%d", old_mode.origin,
       old_mode.mode, new_mode.origin, new_mode.mode));
 
   search_mode_ = new_mode;
   if (!new_mode.is_search_suggestions())
     HideOverlay();
 
   ResetInstantTab();
 
   if (instant_tab_ && old_mode.is_ntp() != new_mode.is_ntp())
-    instant_tab_->SetInputInProgress(IsInputInProgress());
+    instant_tab_->sender()->SetInputInProgress(IsInputInProgress());
 }
 
 void InstantController::ActiveTabChanged() {
   if (!extended_enabled() && !instant_enabled_)
     return;
 
   LOG_INSTANT_DEBUG_EVENT(this, "ActiveTabChanged");
 
   // When switching tabs, always hide the overlay.
   HideOverlay();
@@ skipping 33 matching lines @@
   overlay_.reset();
   if (extended_enabled() || instant_enabled_)
     ResetOverlay(GetInstantURL());
 
   // Preload the Instant NTP.
   ntp_.reset();
   if (extended_enabled() && preload_ntp_)
     ResetNTP(GetInstantURL());
 
   if (instant_tab_)
-    instant_tab_->SetDisplayInstantResults(instant_enabled_);
+    instant_tab_->sender()->SetDisplayInstantResults(instant_enabled_);
 }
 
 void InstantController::ThemeChanged(const ThemeBackgroundInfo& theme_info) {
   if (!extended_enabled())
     return;
 
   if (overlay_)
-    overlay_->SendThemeBackgroundInfo(theme_info);
+    overlay_->sender()->SendThemeBackgroundInfo(theme_info);
   if (ntp_)
-    ntp_->SendThemeBackgroundInfo(theme_info);
+    ntp_->sender()->SendThemeBackgroundInfo(theme_info);
   if (instant_tab_)
-    instant_tab_->SendThemeBackgroundInfo(theme_info);
+    instant_tab_->sender()->SendThemeBackgroundInfo(theme_info);
 }
 
 void InstantController::SwappedOverlayContents() {
   model_.SetOverlayContents(GetOverlayContents());
 }
 
 void InstantController::FocusedOverlayContents() {
 #if defined(USE_AURA)
   // On aura the omnibox only receives a focus lost if we initiate the focus
   // change. This does that.
@@ skipping 47 matching lines @@
       InstantServiceFactory::GetForProfile(profile());
   if (!instant_service)
     return;
 
   std::vector<InstantMostVisitedItem> items;
   instant_service->GetCurrentMostVisitedItems(&items);
 
   if (overlay_ && GetOverlayContents() &&
       SearchTabHelper::FromWebContents(overlay_->contents())->
           UpdateLastKnownMostVisitedItems(items)) {
-    overlay_->SendMostVisitedItems(items);
+    overlay_->sender()->SendMostVisitedItems(items);
   }
 
   if (ntp_ && ntp_->contents() &&
       SearchTabHelper::FromWebContents(ntp_->contents())->
           UpdateLastKnownMostVisitedItems(items)) {
-    ntp_->SendMostVisitedItems(items);
+    ntp_->sender()->SendMostVisitedItems(items);
   }
 
   if (instant_tab_ && instant_tab_->contents() &&
       SearchTabHelper::FromWebContents(instant_tab_->contents())->
           UpdateLastKnownMostVisitedItems(items)) {
-    instant_tab_->SendMostVisitedItems(items);
+    instant_tab_->sender()->SendMostVisitedItems(items);
   }
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_INSTANT_SENT_MOST_VISITED_ITEMS,
       content::Source<InstantController>(this),
       content::NotificationService::NoDetails());
 }
 
 void InstantController::DeleteMostVisitedItem(const GURL& url) {
   DCHECK(!url.is_empty());
@@ skipping 45 matching lines @@
 void InstantController::InstantPageRenderViewCreated(
     const content::WebContents* contents) {
   if (!extended_enabled())
     return;
 
   // Update theme info so that the page picks it up.
   browser_->UpdateThemeInfo();
 
   // Ensure the searchbox API has the correct initial state.
   if (IsContentsFrom(overlay(), contents)) {
-    overlay_->SetDisplayInstantResults(instant_enabled_);
-    overlay_->FocusChanged(omnibox_focus_state_, omnibox_focus_change_reason_);
-    overlay_->SetOmniboxBounds(omnibox_bounds_);
+    overlay_->sender()->SetDisplayInstantResults(instant_enabled_);
+    overlay_->sender()->FocusChanged(omnibox_focus_state_,
+                                     omnibox_focus_change_reason_);
+    overlay_->sender()->SetOmniboxBounds(omnibox_bounds_);
     overlay_->InitializeFonts();
   } else if (IsContentsFrom(ntp(), contents)) {
-    ntp_->SetDisplayInstantResults(instant_enabled_);
-    ntp_->SetOmniboxBounds(omnibox_bounds_);
+    ntp_->sender()->SetDisplayInstantResults(instant_enabled_);
+    ntp_->sender()->SetOmniboxBounds(omnibox_bounds_);
     ntp_->InitializeFonts();
   } else {
     NOTREACHED();
   }
   UpdateMostVisitedItems();
 }
 
 void InstantController::InstantSupportChanged(
     InstantSupportState instant_support) {
   // Handle INSTANT_SUPPORT_YES here because InstantPage is not hooked up to the
@@ skipping 329 matching lines @@
 }
 
 void InstantController::ResetNTP(const std::string& instant_url) {
   // Never load the Instant NTP if it is disabled.
   if (!chrome::ShouldShowInstantNTP())
     return;
 
   // Instant NTP is only used in extended mode so we should always have a
   // non-empty URL to use.
   DCHECK(!instant_url.empty());
-  ntp_.reset(new InstantNTP(this, instant_url));
+  ntp_.reset(new InstantNTP(this, instant_url,
+                            browser_->profile()->IsOffTheRecord()));
   ntp_->InitContents(profile(), browser_->GetActiveWebContents(),
                      base::Bind(&InstantController::ReloadStaleNTP,
                                 base::Unretained(this)));
   LOG_INSTANT_DEBUG_EVENT(this, base::StringPrintf(
       "ResetNTP: instant_url='%s'", instant_url.c_str()));
 }
 
 void InstantController::ReloadStaleNTP() {
   ResetNTP(GetInstantURL());
 }
@@ skipping 41 matching lines @@
     return INSTANT_FALLBACK_NONE;
 
   bool page_is_current = PageIsCurrent(overlay());
   if (!page_is_current)
     return DetermineFallbackReason(overlay(), GetInstantURL());
 
   return INSTANT_FALLBACK_NONE;
 }
 
 void InstantController::ResetInstantTab() {
-  // Do not wire up the InstantTab in Incognito, to prevent it from sending data
-  // to the page.
-  if (!search_mode_.is_origin_default() &&
-      !browser_->profile()->IsOffTheRecord()) {
+  if (!search_mode_.is_origin_default()) {
     content::WebContents* active_tab = browser_->GetActiveWebContents();
     if (!instant_tab_ || active_tab != instant_tab_->contents()) {
-      instant_tab_.reset(new InstantTab(this));
+      instant_tab_.reset(
+          new InstantTab(this, browser_->profile()->IsOffTheRecord()));
       instant_tab_->Init(active_tab);
       UpdateInfoForInstantTab();
       use_tab_for_suggestions_ = true;
     }
 
     // Hide the |overlay_| since we are now using |instant_tab_| instead.
     HideOverlay();
   } else {
     instant_tab_.reset();
   }
 }
 
 void InstantController::UpdateInfoForInstantTab() {
   if (instant_tab_) {
     browser_->UpdateThemeInfo();
-    instant_tab_->SetDisplayInstantResults(instant_enabled_);
-    instant_tab_->SetOmniboxBounds(omnibox_bounds_);
+    instant_tab_->sender()->SetDisplayInstantResults(instant_enabled_);
+    instant_tab_->sender()->SetOmniboxBounds(omnibox_bounds_);
     instant_tab_->InitializeFonts();
     UpdateMostVisitedItems();
-    instant_tab_->FocusChanged(omnibox_focus_state_,
-                               omnibox_focus_change_reason_);
-    instant_tab_->SetInputInProgress(IsInputInProgress());
+    instant_tab_->sender()->FocusChanged(omnibox_focus_state_,
+                                         omnibox_focus_change_reason_);
+    instant_tab_->sender()->SetInputInProgress(IsInputInProgress());
   }
 }
 
 bool InstantController::IsInputInProgress() const {
   return !search_mode_.is_ntp() &&
       omnibox_focus_state_ == OMNIBOX_FOCUS_VISIBLE;
 }
 
 void InstantController::HideOverlay() {
   HideInternal();
@@ skipping 82 matching lines @@
 
   // In the current Chrome UI, these must always be true so they sanity check
   // the above operations. In a future UI, these may be removed or adjusted.
   // There is no point in sanity-checking |intersection.y()| because the omnibox
   // can be placed anywhere vertically relative to the overlay (for example, in
   // Mac fullscreen mode, the omnibox is fully enclosed by the overlay bounds).
   DCHECK_LE(0, intersection.x());
   DCHECK_LE(0, intersection.width());
   DCHECK_LE(0, intersection.height());
 
-  overlay_->SetPopupBounds(intersection);
+  overlay_->sender()->SetPopupBounds(intersection);
 }
 
 
 
 bool InstantController::FixSuggestion(InstantSuggestion* suggestion) const {
   // We only accept suggestions if the user has typed text. If the user is
   // arrowing up/down (|last_user_text_| is empty), we reject suggestions.
   if (last_user_text_.empty())
     return false;
 
@@ skipping 108 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();
 }