Implement SearchTabHelperDelegate.

chrome/browser/ui/search/search_tab_helper.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/search_tab_helper.h"
 
 #include <set>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_util.h"
-#include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
-#include "chrome/browser/history/most_visited_tiles_experiment.h"
-#include "chrome/browser/history/top_sites.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search/instant_service.h"
 #include "chrome/browser/search/instant_service_factory.h"
 #include "chrome/browser/search/search.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/ui/app_list/app_list_util.h"
-#include "chrome/browser/ui/browser.h"
-#include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/omnibox/location_bar.h"
 #include "chrome/browser/ui/omnibox/omnibox_edit_model.h"
 #include "chrome/browser/ui/omnibox/omnibox_popup_model.h"
 #include "chrome/browser/ui/omnibox/omnibox_view.h"
 #include "chrome/browser/ui/search/search_ipc_router_policy_impl.h"
+#include "chrome/browser/ui/search/search_tab_helper_delegate.h"
 #include "chrome/browser/ui/tab_contents/core_tab_helper.h"
-#include "chrome/browser/ui/tabs/tab_strip_model.h"
-#include "chrome/browser/ui/tabs/tab_strip_model_utils.h"
 #include "chrome/browser/ui/webui/ntp/ntp_user_data_logger.h"
 #include "chrome/common/url_constants.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/navigation_type.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_process_host.h"
@@ skipping 61 matching lines @@
   if (!profile || !contents)
     return false;
 
   InstantService* instant_service =
       InstantServiceFactory::GetForProfile(profile);
   return instant_service &&
       instant_service->IsInstantProcess(
           contents->GetRenderProcessHost()->GetID());
 }
 
-// Updates the location bar to reflect |contents| Instant support state.
-void UpdateLocationBar(content::WebContents* contents) {
-// iOS and Android don't use the Instant framework.
-#if !defined(OS_IOS) && !defined(OS_ANDROID)
-  if (!contents)
-    return;
-
-  Browser* browser = chrome::FindBrowserWithWebContents(contents);
-  if (!browser)
-    return;
-  browser->OnWebContentsInstantSupportDisabled(contents);
-#endif
-}
-
 // Called when an NTP finishes loading. If the load start time was noted,
 // calculates and logs the total load time.
 void RecordNewTabLoadTime(content::WebContents* contents) {
   CoreTabHelper* core_tab_helper = CoreTabHelper::FromWebContents(contents);
   if (core_tab_helper->new_tab_start_time().is_null())
     return;
 
   base::TimeDelta duration =
       base::TimeTicks::Now() - core_tab_helper->new_tab_start_time();
   UMA_HISTOGRAM_TIMES("Tab.NewTabOnload", duration);
   core_tab_helper->set_new_tab_start_time(base::TimeTicks());
 }
 
-// Returns the OmniboxView for |contents| or NULL if not available.
-OmniboxView* GetOmniboxView(content::WebContents* contents) {
-  // iOS and Android don't use the Instant framework.
-#if defined(OS_IOS) || defined(OS_ANDROID)
-  return NULL;
-#else
-  if (!contents)
-    return NULL;
-  Browser* browser = chrome::FindBrowserWithWebContents(contents);
-  return browser ? browser->window()->GetLocationBar()->GetOmniboxView() : NULL;
-#endif
-}
-
 }  // namespace
 
 SearchTabHelper::SearchTabHelper(content::WebContents* web_contents)
     : WebContentsObserver(web_contents),
       is_search_enabled_(chrome::IsInstantExtendedAPIEnabled()),
       web_contents_(web_contents),
       ipc_router_(web_contents, this,
                   make_scoped_ptr(new SearchIPCRouterPolicyImpl(web_contents))
                       .PassAs<SearchIPCRouter::Policy>()),
-      instant_service_(NULL) {
+      instant_service_(NULL),
+      delegate_(NULL) {
   if (!is_search_enabled_)
     return;
 
   instant_service_ =
       InstantServiceFactory::GetForProfile(
           Profile::FromBrowserContext(web_contents_->GetBrowserContext()));
   if (instant_service_)
     instant_service_->AddObserver(this);
 }
 
@@ skipping 43 matching lines @@
 
   InstantSupportState new_state = instant_support ? INSTANT_SUPPORT_YES :
       INSTANT_SUPPORT_NO;
 
   model_.SetInstantSupportState(new_state);
 
   content::NavigationEntry* entry =
       web_contents_->GetController().GetVisibleEntry();
   if (entry) {
     chrome::SetInstantSupportStateInNavigationEntry(new_state, entry);
-    if (!instant_support)
-      UpdateLocationBar(web_contents_);
+    if (delegate_ && !instant_support)
+      delegate_->OnWebContentsInstantSupportDisabled(web_contents_);
   }
 }
 
 bool SearchTabHelper::SupportsInstant() const {
   return model_.instant_support() == INSTANT_SUPPORT_YES;
 }
 
 void SearchTabHelper::SetSuggestionToPrefetch(
     const InstantSuggestion& suggestion) {
   ipc_router_.SetSuggestionToPrefetch(suggestion);
@@ skipping 134 matching lines @@
   // crbug.com/251330 for more details.
   if (load_details.is_in_page ||
       load_details.type == content::NAVIGATION_TYPE_IN_PAGE) {
     // When an "in-page" navigation happens, we will not receive a
     // DidFinishLoad() event. Therefore, we will not determine the Instant
     // support for the navigated page. So, copy over the Instant support from
     // the previous entry. If the page does not support Instant, update the
     // location bar from here to turn off search terms replacement.
     chrome::SetInstantSupportStateInNavigationEntry(model_.instant_support(),
                                                     entry);
-    if (model_.instant_support() == INSTANT_SUPPORT_NO)
-      UpdateLocationBar(web_contents_);
+    if (delegate_ && model_.instant_support() == INSTANT_SUPPORT_NO)
+      delegate_->OnWebContentsInstantSupportDisabled(web_contents_);
     return;
   }
 
   model_.SetInstantSupportState(INSTANT_SUPPORT_UNKNOWN);
   model_.SetVoiceSearchSupported(false);
   chrome::SetInstantSupportStateInNavigationEntry(model_.instant_support(),
                                                   entry);
 }
 
 void SearchTabHelper::OnInstantSupportDetermined(bool supports_instant) {
   InstantSupportChanged(supports_instant);
 }
 
 void SearchTabHelper::OnSetVoiceSearchSupport(bool supports_voice_search) {
   model_.SetVoiceSearchSupported(supports_voice_search);
 }
 
 void SearchTabHelper::ThemeInfoChanged(const ThemeBackgroundInfo& theme_info) {
   ipc_router_.SendThemeBackgroundInfo(theme_info);
 }
 
 void SearchTabHelper::MostVisitedItemsChanged(
     const std::vector<InstantMostVisitedItem>& items) {
   std::vector<InstantMostVisitedItem> items_copy(items);
-  MaybeRemoveMostVisitedItems(&items_copy);
+  if (delegate_)
+    delegate_->RemoveMostVisitedItemsMatchingOpenTabs(&items_copy);
+
   ipc_router_.SendMostVisitedItems(items_copy);
 }
 
 void SearchTabHelper::OmniboxStartMarginChanged(int omnibox_start_margin) {
   ipc_router_.SetOmniboxStartMargin(omnibox_start_margin);
 }
 
-void SearchTabHelper::MaybeRemoveMostVisitedItems(
-    std::vector<InstantMostVisitedItem>* items) {
-// The code below uses APIs not available on Android and the experiment should
-// not run there.
-#if !defined(OS_ANDROID)
-  if (!history::MostVisitedTilesExperiment::IsDontShowOpenURLsEnabled())
-    return;
-
-  Profile* profile =
-      Profile::FromBrowserContext(web_contents_->GetBrowserContext());
-  if (!profile)
-    return;
-
-  Browser* browser = chrome::FindBrowserWithProfile(profile,
-                                                    chrome::GetActiveDesktop());
-  if (!browser)
-    return;
-
-  TabStripModel* tab_strip_model = browser->tab_strip_model();
-  history::TopSites* top_sites = profile->GetTopSites();
-  if (!tab_strip_model || !top_sites) {
-    NOTREACHED();
-    return;
-  }
-
-  std::set<std::string> open_urls;
-  chrome::GetOpenUrls(*tab_strip_model, *top_sites, &open_urls);
-  history::MostVisitedTilesExperiment::RemoveItemsMatchingOpenTabs(
-      open_urls, items);
-#endif
-}
-
 void SearchTabHelper::FocusOmnibox(OmniboxFocusState state) {
-  OmniboxView* omnibox = GetOmniboxView(web_contents());
+  OmniboxView* omnibox = delegate_ ? delegate_->GetOmniboxView() : NULL;
   if (!omnibox)
     return;
 
   // Do not add a default case in the switch block for the following reasons:
   // (1) Explicitly handle the new states. If new states are added in the
   // OmniboxFocusState, the compiler will warn the developer to handle the new
   // states.
   // (2) An attacker may control the renderer and sends the browser process a
   // malformed IPC. This function responds to the invalid |state| values by
   // doing nothing instead of crashing the browser process (intentional no-op).
@@ skipping 19 matching lines @@
       // interaction.
       if (!omnibox->model()->popup_model()->IsOpen())
         web_contents()->GetView()->Focus();
       break;
   }
 }
 
 void SearchTabHelper::NavigateToURL(const GURL& url,
                                     WindowOpenDisposition disposition,
                                     bool is_most_visited_item_url) {
-// iOS and Android don't use the Instant framework.
-#if !defined(OS_IOS) && !defined(OS_ANDROID)
-  // TODO(kmadhusu): Remove chrome::FindBrowser...() function call from here.
-  // Create a SearchTabHelperDelegate interface and have the Browser object
-  // implement that interface to provide the necessary functionality.
-  Browser* browser = chrome::FindBrowserWithWebContents(web_contents_);
-  Profile* profile =
-      Profile::FromBrowserContext(web_contents_->GetBrowserContext());
-  if (!browser || !profile)
-    return;
-
   if (is_most_visited_item_url) {
     content::RecordAction(
         base::UserMetricsAction("InstantExtended.MostVisitedClicked"));
   }
 
-  chrome::NavigateParams params(browser, url,
-                                content::PAGE_TRANSITION_AUTO_BOOKMARK);
-  params.referrer = content::Referrer();
-  params.source_contents = web_contents_;
-  params.disposition = disposition;
-  params.is_renderer_initiated = false;
-  params.initiating_profile = profile;
-  chrome::Navigate(&params);
-#endif
+  if (delegate_)
+    delegate_->NavigateToURL(url, disposition, web_contents_);
 }
 
 void SearchTabHelper::OnDeleteMostVisitedItem(const GURL& url) {
   DCHECK(!url.is_empty());
   if (instant_service_)
     instant_service_->DeleteMostVisitedItem(url);
 }
 
 void SearchTabHelper::OnUndoMostVisitedDeletion(const GURL& url) {
   DCHECK(!url.is_empty());
@@ skipping 17 matching lines @@
       web_contents())->LogMostVisitedImpression(position, provider);
 }
 
 void SearchTabHelper::OnLogMostVisitedNavigation(
     int position, const base::string16& provider) {
   NTPUserDataLogger::GetOrCreateFromWebContents(
       web_contents())->LogMostVisitedNavigation(position, provider);
 }
 
 void SearchTabHelper::PasteIntoOmnibox(const base::string16& text) {
-  OmniboxView* omnibox = GetOmniboxView(web_contents());
+  OmniboxView* omnibox = delegate_ ? delegate_->GetOmniboxView() : NULL;
   if (!omnibox)
     return;
 
   // The first case is for right click to paste, where the text is retrieved
   // from the clipboard already sanitized. The second case is needed to handle
   // drag-and-drop value and it has to be sanitazed before setting it into the
   // omnibox.
   base::string16 text_to_paste = text.empty() ? omnibox->GetClipboardText() :
       omnibox->SanitizeTextForPaste(text);
 
@@ skipping 25 matching lines @@
   if (IsNTP(web_contents_) || is_preloaded_ntp) {
     type = SearchMode::MODE_NTP;
     origin = SearchMode::ORIGIN_NTP;
   } else if (IsSearchResults(web_contents_)) {
     type = SearchMode::MODE_SEARCH_RESULTS;
     origin = SearchMode::ORIGIN_SEARCH;
   }
   if (!update_origin)
     origin = model_.mode().origin;
 
-  OmniboxView* omnibox = GetOmniboxView(web_contents());
+  OmniboxView* omnibox = delegate_ ? delegate_->GetOmniboxView() : NULL;

[Jered, 2014/04/04 22:39:27]

Extract a helper GetOmniboxView() and have it return this, instead of
replicating the ? : expression.

[kmadhusu, 2014/04/07 21:44:15]

Done.

   if (omnibox && omnibox->model()->user_input_in_progress())
     type = SearchMode::MODE_SEARCH_SUGGESTIONS;
 
   SearchMode old_mode(model_.mode());
   model_.SetMode(SearchMode(type, origin));
   if (old_mode.is_ntp() != model_.mode().is_ntp()) {
     ipc_router_.SetInputInProgress(IsInputInProgress());
   }
 }
 
@@ skipping 21 matching lines @@
   content::NavigationController::LoadURLParams load_params(
       (GURL(chrome::kChromeSearchLocalNtpUrl)));
   load_params.referrer = content::Referrer();
   load_params.transition_type = content::PAGE_TRANSITION_SERVER_REDIRECT;
   // Don't push a history entry.
   load_params.should_replace_current_entry = true;
   web_contents_->GetController().LoadURLWithParams(load_params);
 }
 
 bool SearchTabHelper::IsInputInProgress() const {
-  OmniboxView* omnibox = GetOmniboxView(web_contents());
+  OmniboxView* omnibox = delegate_ ? delegate_->GetOmniboxView() : NULL;
   return !model_.mode().is_ntp() && omnibox &&
       omnibox->model()->focus_state() == OMNIBOX_FOCUS_VISIBLE;
 }