src/chrome/browser/ui/search/search_tab_helper.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/search/search_tab_helper.h"
   6
   7 #include <set>
   8
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/metrics/histogram.h"
  11 #include "base/strings/string16.h"
  12 #include "base/strings/string_util.h"
  13 #include "chrome/browser/chrome_notification_types.h"
  14 #include "chrome/browser/profiles/profile.h"
  15 #include "chrome/browser/search/instant_service.h"
  16 #include "chrome/browser/search/instant_service_factory.h"
  17 #include "chrome/browser/search/search.h"
  18 #include "chrome/browser/signin/signin_manager_factory.h"
  19 #include "chrome/browser/sync/profile_sync_service.h"
  20 #include "chrome/browser/sync/profile_sync_service_factory.h"
  21 #include "chrome/browser/ui/app_list/app_list_util.h"
  22 #include "chrome/browser/ui/browser_navigator.h"
  23 #include "chrome/browser/ui/browser_window.h"
  24 #include "chrome/browser/ui/location_bar/location_bar.h"
  25 #include "chrome/browser/ui/omnibox/omnibox_edit_model.h"
  26 #include "chrome/browser/ui/omnibox/omnibox_popup_model.h"
  27 #include "chrome/browser/ui/omnibox/omnibox_view.h"
  28 #include "chrome/browser/ui/search/instant_search_prerenderer.h"
  29 #include "chrome/browser/ui/search/search_ipc_router_policy_impl.h"
  30 #include "chrome/browser/ui/search/search_tab_helper_delegate.h"
  31 #include "chrome/browser/ui/tab_contents/core_tab_helper.h"
  32 #include "chrome/browser/ui/webui/ntp/ntp_user_data_logger.h"
  33 #include "chrome/common/url_constants.h"
  34 #include "chrome/grit/generated_resources.h"
  35 #include "components/google/core/browser/google_util.h"
  36 #include "components/search/search.h"
  37 #include "components/signin/core/browser/signin_manager.h"
  38 #include "content/public/browser/navigation_controller.h"
  39 #include "content/public/browser/navigation_details.h"
  40 #include "content/public/browser/navigation_entry.h"
  41 #include "content/public/browser/navigation_type.h"
  42 #include "content/public/browser/notification_service.h"
  43 #include "content/public/browser/notification_source.h"
  44 #include "content/public/browser/render_frame_host.h"
  45 #include "content/public/browser/render_process_host.h"
  46 #include "content/public/browser/user_metrics.h"
  47 #include "content/public/browser/web_contents.h"
  48 #include "content/public/common/referrer.h"
  49 #include "net/base/net_errors.h"
  50 #include "ui/base/l10n/l10n_util.h"
  51 #include "ui/base/page_transition_types.h"
  52 #include "url/gurl.h"
  53
  54 DEFINE_WEB_CONTENTS_USER_DATA_KEY(SearchTabHelper);
  55
  56 namespace {
  57
  58 // For reporting Cacheable NTP navigations.
  59 enum CacheableNTPLoad {
  60   CACHEABLE_NTP_LOAD_FAILED = 0,
  61   CACHEABLE_NTP_LOAD_SUCCEEDED = 1,
  62   CACHEABLE_NTP_LOAD_MAX = 2
  63 };
  64
  65 void RecordCacheableNTPLoadHistogram(bool succeeded) {
  66   UMA_HISTOGRAM_ENUMERATION("InstantExtended.CacheableNTPLoad",
  67                             succeeded ? CACHEABLE_NTP_LOAD_SUCCEEDED :
  68                                 CACHEABLE_NTP_LOAD_FAILED,
  69                             CACHEABLE_NTP_LOAD_MAX);
  70 }
  71
  72 bool IsCacheableNTP(const content::WebContents* contents) {
  73   const content::NavigationEntry* entry =
  74       contents->GetController().GetLastCommittedEntry();
  75   return chrome::NavEntryIsInstantNTP(contents, entry) &&
  76       entry->GetURL() != GURL(chrome::kChromeSearchLocalNtpUrl);
  77 }
  78
  79 bool IsNTP(const content::WebContents* contents) {
  80   // We can't use WebContents::GetURL() because that uses the active entry,
  81   // whereas we want the visible entry.
  82   const content::NavigationEntry* entry =
  83       contents->GetController().GetVisibleEntry();
  84   if (entry && entry->GetVirtualURL() == GURL(chrome::kChromeUINewTabURL))
  85     return true;
  86
  87   return chrome::IsInstantNTP(contents);
  88 }
  89
  90 bool IsSearchResults(const content::WebContents* contents) {
  91   return !chrome::GetSearchTerms(contents).empty();
  92 }
  93
  94 bool IsLocal(const content::WebContents* contents) {
  95   if (!contents)
  96     return false;
  97   const content::NavigationEntry* entry =
  98       contents->GetController().GetVisibleEntry();
  99   return entry && entry->GetURL() == GURL(chrome::kChromeSearchLocalNtpUrl);
 100 }
 101
 102 // Returns true if |contents| are rendered inside an Instant process.
 103 bool InInstantProcess(Profile* profile,
 104                       const content::WebContents* contents) {
 105   if (!profile || !contents)
 106     return false;
 107
 108   InstantService* instant_service =
 109       InstantServiceFactory::GetForProfile(profile);
 110   return instant_service &&
 111       instant_service->IsInstantProcess(
 112           contents->GetRenderProcessHost()->GetID());
 113 }
 114
 115 // Called when an NTP finishes loading. If the load start time was noted,
 116 // calculates and logs the total load time.
 117 void RecordNewTabLoadTime(content::WebContents* contents) {
 118   CoreTabHelper* core_tab_helper = CoreTabHelper::FromWebContents(contents);
 119   if (core_tab_helper->new_tab_start_time().is_null())
 120     return;
 121
 122   base::TimeDelta duration =
 123       base::TimeTicks::Now() - core_tab_helper->new_tab_start_time();
 124   if (IsCacheableNTP(contents)) {
 125     if (google_util::IsGoogleDomainUrl(
 126         contents->GetController().GetLastCommittedEntry()->GetURL(),
 127         google_util::ALLOW_SUBDOMAIN,
 128         google_util::DISALLOW_NON_STANDARD_PORTS)) {
 129       UMA_HISTOGRAM_TIMES("Tab.NewTabOnload.Google", duration);
 130     } else {
 131       UMA_HISTOGRAM_TIMES("Tab.NewTabOnload.Other", duration);
 132     }
 133   } else {
 134     UMA_HISTOGRAM_TIMES("Tab.NewTabOnload.Local", duration);
 135   }
 136   core_tab_helper->set_new_tab_start_time(base::TimeTicks());
 137 }
 138
 139 // Returns true if the user is signed in and full history sync is enabled,
 140 // and false otherwise.
 141 bool IsHistorySyncEnabled(Profile* profile) {
 142   ProfileSyncService* sync =
 143       ProfileSyncServiceFactory::GetInstance()->GetForProfile(profile);
 144   return sync &&
 145       sync->sync_initialized() &&
 146       sync->GetActiveDataTypes().Has(syncer::HISTORY_DELETE_DIRECTIVES);
 147 }
 148
 149 bool OmniboxHasFocus(OmniboxView* omnibox) {
 150   return omnibox && omnibox->model()->has_focus();
 151 }
 152
 153 }  // namespace
 154
 155 SearchTabHelper::SearchTabHelper(content::WebContents* web_contents)
 156     : WebContentsObserver(web_contents),
 157       is_search_enabled_(chrome::IsInstantExtendedAPIEnabled()),
 158       web_contents_(web_contents),
 159       ipc_router_(web_contents, this,
 160                   make_scoped_ptr(new SearchIPCRouterPolicyImpl(web_contents))
 161                       .PassAs<SearchIPCRouter::Policy>()),
 162       instant_service_(NULL),
 163       delegate_(NULL),
 164       omnibox_has_focus_fn_(&OmniboxHasFocus) {
 165   if (!is_search_enabled_)
 166     return;
 167
 168   instant_service_ =
 169       InstantServiceFactory::GetForProfile(
 170           Profile::FromBrowserContext(web_contents_->GetBrowserContext()));
 171   if (instant_service_)
 172     instant_service_->AddObserver(this);
 173 }
 174
 175 SearchTabHelper::~SearchTabHelper() {
 176   if (instant_service_)
 177     instant_service_->RemoveObserver(this);
 178 }
 179
 180 void SearchTabHelper::InitForPreloadedNTP() {
 181   UpdateMode(true, true);
 182 }
 183
 184 void SearchTabHelper::OmniboxInputStateChanged() {
 185   if (!is_search_enabled_)
 186     return;
 187
 188   UpdateMode(false, false);
 189 }
 190
 191 void SearchTabHelper::OmniboxFocusChanged(OmniboxFocusState state,
 192                                           OmniboxFocusChangeReason reason) {
 193   content::NotificationService::current()->Notify(
 194       chrome::NOTIFICATION_OMNIBOX_FOCUS_CHANGED,
 195       content::Source<SearchTabHelper>(this),
 196       content::NotificationService::NoDetails());
 197
 198   ipc_router_.OmniboxFocusChanged(state, reason);
 199
 200   // Don't send oninputstart/oninputend updates in response to focus changes
 201   // if there's a navigation in progress. This prevents Chrome from sending
 202   // a spurious oninputend when the user accepts a match in the omnibox.
 203   if (web_contents_->GetController().GetPendingEntry() == NULL) {
 204     ipc_router_.SetInputInProgress(IsInputInProgress());
 205
 206     InstantSearchPrerenderer* prerenderer =
 207         InstantSearchPrerenderer::GetForProfile(profile());
 208     if (!prerenderer || !chrome::ShouldPrerenderInstantUrlOnOmniboxFocus())
 209       return;
 210
 211     if (state == OMNIBOX_FOCUS_NONE) {
 212       prerenderer->Cancel();
 213       return;
 214     }
 215
 216     if (!IsSearchResultsPage()) {
 217       prerenderer->Init(
 218           web_contents_->GetController().GetSessionStorageNamespaceMap(),
 219           web_contents_->GetContainerBounds().size());
 220     }
 221   }
 222 }
 223
 224 void SearchTabHelper::NavigationEntryUpdated() {
 225   if (!is_search_enabled_)
 226     return;
 227
 228   UpdateMode(false, false);
 229 }
 230
 231 void SearchTabHelper::InstantSupportChanged(bool instant_support) {
 232   if (!is_search_enabled_)
 233     return;
 234
 235   InstantSupportState new_state = instant_support ? INSTANT_SUPPORT_YES :
 236       INSTANT_SUPPORT_NO;
 237
 238   model_.SetInstantSupportState(new_state);
 239
 240   content::NavigationEntry* entry =
 241       web_contents_->GetController().GetLastCommittedEntry();
 242   if (entry) {
 243     chrome::SetInstantSupportStateInNavigationEntry(new_state, entry);
 244     if (delegate_ && !instant_support)
 245       delegate_->OnWebContentsInstantSupportDisabled(web_contents_);
 246   }
 247 }
 248
 249 bool SearchTabHelper::SupportsInstant() const {
 250   return model_.instant_support() == INSTANT_SUPPORT_YES;
 251 }
 252
 253 void SearchTabHelper::SetSuggestionToPrefetch(
 254     const InstantSuggestion& suggestion) {
 255   ipc_router_.SetSuggestionToPrefetch(suggestion);
 256 }
 257
 258 void SearchTabHelper::Submit(const base::string16& text) {
 259   ipc_router_.Submit(text);
 260 }
 261
 262 void SearchTabHelper::OnTabActivated() {
 263   ipc_router_.OnTabActivated();
 264
 265   OmniboxView* omnibox_view = GetOmniboxView();
 266   if (chrome::ShouldPrerenderInstantUrlOnOmniboxFocus() &&
 267       omnibox_has_focus_fn_(omnibox_view)) {
 268     InstantSearchPrerenderer* prerenderer =
 269         InstantSearchPrerenderer::GetForProfile(profile());
 270     if (prerenderer && !IsSearchResultsPage()) {
 271       prerenderer->Init(
 272           web_contents_->GetController().GetSessionStorageNamespaceMap(),
 273           web_contents_->GetContainerBounds().size());
 274     }
 275   }
 276 }
 277
 278 void SearchTabHelper::OnTabDeactivated() {
 279   ipc_router_.OnTabDeactivated();
 280 }
 281
 282 void SearchTabHelper::ToggleVoiceSearch() {
 283   ipc_router_.ToggleVoiceSearch();
 284 }
 285
 286 bool SearchTabHelper::IsSearchResultsPage() {
 287   return model_.mode().is_origin_search();
 288 }
 289
 290 void SearchTabHelper::RenderViewCreated(
 291     content::RenderViewHost* render_view_host) {
 292   ipc_router_.SetPromoInformation(IsAppLauncherEnabled());
 293 }
 294
 295 void SearchTabHelper::DidStartNavigationToPendingEntry(
 296     const GURL& url,
 297     content::NavigationController::ReloadType /* reload_type */) {
 298   if (chrome::IsNTPURL(url, profile())) {
 299     // Set the title on any pending entry corresponding to the NTP. This
 300     // prevents any flickering of the tab title.
 301     content::NavigationEntry* entry =
 302         web_contents_->GetController().GetPendingEntry();
 303     if (entry)
 304       entry->SetTitle(l10n_util::GetStringUTF16(IDS_NEW_TAB_TITLE));
 305   }
 306 }
 307
 308 void SearchTabHelper::DidNavigateMainFrame(
 309     const content::LoadCommittedDetails& details,
 310     const content::FrameNavigateParams& params) {
 311   if (IsCacheableNTP(web_contents_)) {
 312     if (details.http_status_code == 204 || details.http_status_code >= 400) {
 313       RedirectToLocalNTP();
 314       RecordCacheableNTPLoadHistogram(false);
 315       return;
 316     }
 317     RecordCacheableNTPLoadHistogram(true);
 318   }
 319
 320   // Always set the title on the new tab page to be the one from our UI
 321   // resources. Normally, we set the title when we begin a NTP load, but it can
 322   // get reset in several places (like when you press Reload). This check
 323   // ensures that the title is properly set to the string defined by the Chrome
 324   // UI language (rather than the server language) in all cases.
 325   //
 326   // We only override the title when it's nonempty to allow the page to set the
 327   // title if it really wants. An empty title means to use the default. There's
 328   // also a race condition between this code and the page's SetTitle call which
 329   // this rule avoids.
 330   content::NavigationEntry* entry =
 331       web_contents_->GetController().GetLastCommittedEntry();
 332   if (entry && entry->GetTitle().empty() &&
 333       (entry->GetVirtualURL() == GURL(chrome::kChromeUINewTabURL) ||
 334        chrome::NavEntryIsInstantNTP(web_contents_, entry))) {
 335     entry->SetTitle(l10n_util::GetStringUTF16(IDS_NEW_TAB_TITLE));
 336   }
 337 }
 338
 339 void SearchTabHelper::DidFailProvisionalLoad(
 340     content::RenderFrameHost* render_frame_host,
 341     const GURL& validated_url,
 342     int error_code,
 343     const base::string16& /* error_description */) {
 344   // If error_code is ERR_ABORTED means that the user has canceled this
 345   // navigation so it shouldn't be redirected.
 346   if (!render_frame_host->GetParent() && error_code != net::ERR_ABORTED &&
 347       validated_url != GURL(chrome::kChromeSearchLocalNtpUrl) &&
 348       chrome::IsNTPURL(validated_url, profile())) {
 349     RedirectToLocalNTP();
 350     RecordCacheableNTPLoadHistogram(false);
 351   }
 352 }
 353
 354 void SearchTabHelper::DidFinishLoad(content::RenderFrameHost* render_frame_host,
 355                                     const GURL& /* validated_url */) {
 356   if (!render_frame_host->GetParent()) {
 357     if (chrome::IsInstantNTP(web_contents_))
 358       RecordNewTabLoadTime(web_contents_);
 359
 360     DetermineIfPageSupportsInstant();
 361   }
 362 }
 363
 364 void SearchTabHelper::NavigationEntryCommitted(
 365     const content::LoadCommittedDetails& load_details) {
 366   if (!is_search_enabled_)
 367     return;
 368
 369   if (!load_details.is_main_frame)
 370     return;
 371
 372   if (chrome::ShouldAssignURLToInstantRenderer(web_contents_->GetURL(),
 373                                                profile())) {
 374     InstantService* instant_service =
 375         InstantServiceFactory::GetForProfile(profile());
 376     ipc_router_.SetOmniboxStartMargin(instant_service->omnibox_start_margin());
 377     ipc_router_.SetDisplayInstantResults();
 378   }
 379
 380   UpdateMode(true, false);
 381
 382   content::NavigationEntry* entry =
 383       web_contents_->GetController().GetVisibleEntry();
 384   DCHECK(entry);
 385
 386   // Already determined the instant support state for this page, do not reset
 387   // the instant support state.
 388   //
 389   // When we get a navigation entry committed event, there seem to be two ways
 390   // to tell whether the navigation was "in-page". Ideally, when
 391   // LoadCommittedDetails::is_in_page is true, we should have
 392   // LoadCommittedDetails::type to be NAVIGATION_TYPE_IN_PAGE. Unfortunately,
 393   // they are different in some cases. To workaround this bug, we are checking
 394   // (is_in_page || type == NAVIGATION_TYPE_IN_PAGE). Please refer to
 395   // crbug.com/251330 for more details.
 396   if (load_details.is_in_page ||
 397       load_details.type == content::NAVIGATION_TYPE_IN_PAGE) {
 398     // When an "in-page" navigation happens, we will not receive a
 399     // DidFinishLoad() event. Therefore, we will not determine the Instant
 400     // support for the navigated page. So, copy over the Instant support from
 401     // the previous entry. If the page does not support Instant, update the
 402     // location bar from here to turn off search terms replacement.
 403     chrome::SetInstantSupportStateInNavigationEntry(model_.instant_support(),
 404                                                     entry);
 405     if (delegate_ && model_.instant_support() == INSTANT_SUPPORT_NO)
 406       delegate_->OnWebContentsInstantSupportDisabled(web_contents_);
 407     return;
 408   }
 409
 410   model_.SetInstantSupportState(INSTANT_SUPPORT_UNKNOWN);
 411   model_.SetVoiceSearchSupported(false);
 412   chrome::SetInstantSupportStateInNavigationEntry(model_.instant_support(),
 413                                                   entry);
 414
 415   if (InInstantProcess(profile(), web_contents_))
 416     ipc_router_.OnNavigationEntryCommitted();
 417 }
 418
 419 void SearchTabHelper::OnInstantSupportDetermined(bool supports_instant) {
 420   InstantSupportChanged(supports_instant);
 421 }
 422
 423 void SearchTabHelper::OnSetVoiceSearchSupport(bool supports_voice_search) {
 424   model_.SetVoiceSearchSupported(supports_voice_search);
 425 }
 426
 427 void SearchTabHelper::ThemeInfoChanged(const ThemeBackgroundInfo& theme_info) {
 428   ipc_router_.SendThemeBackgroundInfo(theme_info);
 429 }
 430
 431 void SearchTabHelper::MostVisitedItemsChanged(
 432     const std::vector<InstantMostVisitedItem>& items) {
 433   ipc_router_.SendMostVisitedItems(items);
 434 }
 435
 436 void SearchTabHelper::OmniboxStartMarginChanged(int omnibox_start_margin) {
 437   ipc_router_.SetOmniboxStartMargin(omnibox_start_margin);
 438 }
 439
 440 void SearchTabHelper::FocusOmnibox(OmniboxFocusState state) {
 441 // TODO(kmadhusu): Move platform specific code from here and get rid of #ifdef.
 442 #if !defined(OS_ANDROID)
 443   OmniboxView* omnibox = GetOmniboxView();
 444   if (!omnibox)
 445     return;
 446
 447   // Do not add a default case in the switch block for the following reasons:
 448   // (1) Explicitly handle the new states. If new states are added in the
 449   // OmniboxFocusState, the compiler will warn the developer to handle the new
 450   // states.
 451   // (2) An attacker may control the renderer and sends the browser process a
 452   // malformed IPC. This function responds to the invalid |state| values by
 453   // doing nothing instead of crashing the browser process (intentional no-op).
 454   switch (state) {
 455     case OMNIBOX_FOCUS_VISIBLE:
 456       omnibox->SetFocus();
 457       omnibox->model()->SetCaretVisibility(true);
 458       break;
 459     case OMNIBOX_FOCUS_INVISIBLE:
 460       omnibox->SetFocus();
 461       omnibox->model()->SetCaretVisibility(false);
 462       // If the user clicked on the fakebox, any text already in the omnibox
 463       // should get cleared when they start typing. Selecting all the existing
 464       // text is a convenient way to accomplish this. It also gives a slight
 465       // visual cue to users who really understand selection state about what
 466       // will happen if they start typing.
 467       omnibox->SelectAll(false);
 468       omnibox->ShowImeIfNeeded();
 469       break;
 470     case OMNIBOX_FOCUS_NONE:
 471       // Remove focus only if the popup is closed. This will prevent someone
 472       // from changing the omnibox value and closing the popup without user
 473       // interaction.
 474       if (!omnibox->model()->popup_model()->IsOpen())
 475         web_contents()->Focus();
 476       break;
 477   }
 478 #endif
 479 }
 480
 481 void SearchTabHelper::NavigateToURL(const GURL& url,
 482                                     WindowOpenDisposition disposition,
 483                                     bool is_most_visited_item_url) {
 484   if (is_most_visited_item_url) {
 485     content::RecordAction(
 486         base::UserMetricsAction("InstantExtended.MostVisitedClicked"));
 487   }
 488
 489   if (delegate_)
 490     delegate_->NavigateOnThumbnailClick(url, disposition, web_contents_);
 491 }
 492
 493 void SearchTabHelper::OnDeleteMostVisitedItem(const GURL& url) {
 494   DCHECK(!url.is_empty());
 495   if (instant_service_)
 496     instant_service_->DeleteMostVisitedItem(url);
 497 }
 498
 499 void SearchTabHelper::OnUndoMostVisitedDeletion(const GURL& url) {
 500   DCHECK(!url.is_empty());
 501   if (instant_service_)
 502     instant_service_->UndoMostVisitedDeletion(url);
 503 }
 504
 505 void SearchTabHelper::OnUndoAllMostVisitedDeletions() {
 506   if (instant_service_)
 507     instant_service_->UndoAllMostVisitedDeletions();
 508 }
 509
 510 void SearchTabHelper::OnLogEvent(NTPLoggingEventType event) {
 511 // TODO(kmadhusu): Move platform specific code from here and get rid of #ifdef.
 512 #if !defined(OS_ANDROID)
 513   NTPUserDataLogger::GetOrCreateFromWebContents(
 514       web_contents())->LogEvent(event);
 515 #endif
 516 }
 517
 518 void SearchTabHelper::OnLogMostVisitedImpression(
 519     int position, const base::string16& provider) {
 520 // TODO(kmadhusu): Move platform specific code from here and get rid of #ifdef.
 521 #if !defined(OS_ANDROID)
 522   NTPUserDataLogger::GetOrCreateFromWebContents(
 523       web_contents())->LogMostVisitedImpression(position, provider);
 524 #endif
 525 }
 526
 527 void SearchTabHelper::OnLogMostVisitedNavigation(
 528     int position, const base::string16& provider) {
 529 // TODO(kmadhusu): Move platform specific code from here and get rid of #ifdef.
 530 #if !defined(OS_ANDROID)
 531   NTPUserDataLogger::GetOrCreateFromWebContents(
 532       web_contents())->LogMostVisitedNavigation(position, provider);
 533 #endif
 534 }
 535
 536 void SearchTabHelper::PasteIntoOmnibox(const base::string16& text) {
 537 // TODO(kmadhusu): Move platform specific code from here and get rid of #ifdef.
 538 #if !defined(OS_ANDROID)
 539   OmniboxView* omnibox = GetOmniboxView();
 540   if (!omnibox)
 541     return;
 542   // The first case is for right click to paste, where the text is retrieved
 543   // from the clipboard already sanitized. The second case is needed to handle
 544   // drag-and-drop value and it has to be sanitazed before setting it into the
 545   // omnibox.
 546   base::string16 text_to_paste = text.empty() ? omnibox->GetClipboardText() :
 547       omnibox->SanitizeTextForPaste(text);
 548
 549   if (text_to_paste.empty())
 550     return;
 551
 552   if (!omnibox->model()->has_focus())
 553     omnibox->SetFocus();
 554
 555   omnibox->OnBeforePossibleChange();
 556   omnibox->model()->OnPaste();
 557   omnibox->SetUserText(text_to_paste);
 558   omnibox->OnAfterPossibleChange();
 559 #endif
 560 }
 561
 562 void SearchTabHelper::OnChromeIdentityCheck(const base::string16& identity) {
 563   SigninManagerBase* manager = SigninManagerFactory::GetForProfile(profile());
 564   if (manager) {
 565     const base::string16 username =
 566         base::UTF8ToUTF16(manager->GetAuthenticatedUsername());
 567     // The identity check only passes if the user is syncing their history.
 568     // TODO(beaudoin): Change this function name and related APIs now that it's
 569     // checking both the identity and the user's sync state.
 570     bool matches = IsHistorySyncEnabled(profile()) && identity == username;
 571     ipc_router_.SendChromeIdentityCheckResult(identity, matches);
 572   }
 573 }
 574
 575 void SearchTabHelper::UpdateMode(bool update_origin, bool is_preloaded_ntp) {
 576   SearchMode::Type type = SearchMode::MODE_DEFAULT;
 577   SearchMode::Origin origin = SearchMode::ORIGIN_DEFAULT;
 578   if (IsNTP(web_contents_) || is_preloaded_ntp) {
 579     type = SearchMode::MODE_NTP;
 580     origin = SearchMode::ORIGIN_NTP;
 581   } else if (IsSearchResults(web_contents_)) {
 582     type = SearchMode::MODE_SEARCH_RESULTS;
 583     origin = SearchMode::ORIGIN_SEARCH;
 584   }
 585   if (!update_origin)
 586     origin = model_.mode().origin;
 587
 588   OmniboxView* omnibox = GetOmniboxView();
 589   if (omnibox && omnibox->model()->user_input_in_progress())
 590     type = SearchMode::MODE_SEARCH_SUGGESTIONS;
 591
 592   SearchMode old_mode(model_.mode());
 593   model_.SetMode(SearchMode(type, origin));
 594   if (old_mode.is_ntp() != model_.mode().is_ntp()) {
 595     ipc_router_.SetInputInProgress(IsInputInProgress());
 596   }
 597 }
 598
 599 void SearchTabHelper::DetermineIfPageSupportsInstant() {
 600   if (!InInstantProcess(profile(), web_contents_)) {
 601     // The page is not in the Instant process. This page does not support
 602     // instant. If we send an IPC message to a page that is not in the Instant
 603     // process, it will never receive it and will never respond. Therefore,
 604     // return immediately.
 605     InstantSupportChanged(false);
 606   } else if (IsLocal(web_contents_)) {
 607     // Local pages always support Instant.
 608     InstantSupportChanged(true);
 609   } else {
 610     ipc_router_.DetermineIfPageSupportsInstant();
 611   }
 612 }
 613
 614 Profile* SearchTabHelper::profile() const {
 615   return Profile::FromBrowserContext(web_contents_->GetBrowserContext());
 616 }
 617
 618 void SearchTabHelper::RedirectToLocalNTP() {
 619   // Extra parentheses to declare a variable.
 620   content::NavigationController::LoadURLParams load_params(
 621       (GURL(chrome::kChromeSearchLocalNtpUrl)));
 622   load_params.referrer = content::Referrer();
 623   load_params.transition_type = ui::PAGE_TRANSITION_SERVER_REDIRECT;
 624   // Don't push a history entry.
 625   load_params.should_replace_current_entry = true;
 626   web_contents_->GetController().LoadURLWithParams(load_params);
 627 }
 628
 629 bool SearchTabHelper::IsInputInProgress() const {
 630   OmniboxView* omnibox = GetOmniboxView();
 631   return !model_.mode().is_ntp() && omnibox &&
 632       omnibox->model()->focus_state() == OMNIBOX_FOCUS_VISIBLE;
 633 }
 634
 635 OmniboxView* SearchTabHelper::GetOmniboxView() const {
 636   return delegate_ ? delegate_->GetOmniboxView() : NULL;
 637 }