Partially componentize //chrome/browser/search/search.{h,cc}

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"
@@ skipping 42 matching lines @@
 #include "ui/base/page_transition_types.h"
 #include "url/gurl.h"
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(SearchTabHelper);
 
 namespace {
 
 bool IsCacheableNTP(const content::WebContents* contents) {
   const content::NavigationEntry* entry =
       contents->GetController().GetLastCommittedEntry();
-  return chrome::NavEntryIsInstantNTP(contents, entry) &&
-      entry->GetURL() != GURL(chrome::kChromeSearchLocalNtpUrl);
+  return search::NavEntryIsInstantNTP(contents, entry) &&
+         entry->GetURL() != GURL(chrome::kChromeSearchLocalNtpUrl);
 }
 
 bool IsNTP(const content::WebContents* contents) {
   // We can't use WebContents::GetURL() because that uses the active entry,
   // whereas we want the visible entry.
   const content::NavigationEntry* entry =
       contents->GetController().GetVisibleEntry();
   if (entry && entry->GetVirtualURL() == GURL(chrome::kChromeUINewTabURL))
     return true;
 
-  return chrome::IsInstantNTP(contents);
+  return search::IsInstantNTP(contents);
 }
 
 bool IsSearchResults(const content::WebContents* contents) {
-  return !chrome::GetSearchTerms(contents).empty();
+  return !search::GetSearchTerms(contents).empty();
 }
 
 bool IsLocal(const content::WebContents* contents) {
   if (!contents)
     return false;
   const content::NavigationEntry* entry =
       contents->GetController().GetVisibleEntry();
   return entry && entry->GetURL() == GURL(chrome::kChromeSearchLocalNtpUrl);
 }
 
@@ skipping 46 matching lines @@
 }
 
 bool OmniboxHasFocus(OmniboxView* omnibox) {
   return omnibox && omnibox->model()->has_focus();
 }
 
 }  // namespace
 
 SearchTabHelper::SearchTabHelper(content::WebContents* web_contents)
     : WebContentsObserver(web_contents),
-      is_search_enabled_(chrome::IsInstantExtendedAPIEnabled()),
+      is_search_enabled_(search::IsInstantExtendedAPIEnabled()),
       web_contents_(web_contents),
       ipc_router_(web_contents,
                   this,
                   make_scoped_ptr(new SearchIPCRouterPolicyImpl(web_contents))),
       instant_service_(NULL),
       delegate_(NULL),
       omnibox_has_focus_fn_(&OmniboxHasFocus) {
   if (!is_search_enabled_)
     return;
 
@@ skipping 30 matching lines @@
   ipc_router_.OmniboxFocusChanged(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 (web_contents_->GetController().GetPendingEntry() == NULL) {
     ipc_router_.SetInputInProgress(IsInputInProgress());
 
     InstantSearchPrerenderer* prerenderer =
         InstantSearchPrerenderer::GetForProfile(profile());
-    if (!prerenderer || !chrome::ShouldPrerenderInstantUrlOnOmniboxFocus())
+    if (!prerenderer || !search::ShouldPrerenderInstantUrlOnOmniboxFocus())
       return;
 
     if (state == OMNIBOX_FOCUS_NONE) {
       prerenderer->Cancel();
       return;
     }
 
     if (!IsSearchResultsPage()) {
       prerenderer->Init(
           web_contents_->GetController().GetDefaultSessionStorageNamespace(),
@@ skipping 14 matching lines @@
     return;
 
   InstantSupportState new_state = instant_support ? INSTANT_SUPPORT_YES :
       INSTANT_SUPPORT_NO;
 
   model_.SetInstantSupportState(new_state);
 
   content::NavigationEntry* entry =
       web_contents_->GetController().GetLastCommittedEntry();
   if (entry) {
-    chrome::SetInstantSupportStateInNavigationEntry(new_state, entry);
+    search::SetInstantSupportStateInNavigationEntry(new_state, entry);
     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);
 }
 
 void SearchTabHelper::Submit(const base::string16& text,
                              const EmbeddedSearchRequestParams& params) {
   ipc_router_.Submit(text, params);
 }
 
 void SearchTabHelper::OnTabActivated() {
   ipc_router_.OnTabActivated();
 
   OmniboxView* omnibox_view = GetOmniboxView();
-  if (chrome::ShouldPrerenderInstantUrlOnOmniboxFocus() &&
+  if (search::ShouldPrerenderInstantUrlOnOmniboxFocus() &&
       omnibox_has_focus_fn_(omnibox_view)) {
     InstantSearchPrerenderer* prerenderer =
         InstantSearchPrerenderer::GetForProfile(profile());
     if (prerenderer && !IsSearchResultsPage()) {
       prerenderer->Init(
           web_contents_->GetController().GetDefaultSessionStorageNamespace(),
           web_contents_->GetContainerBounds().size());
     }
   }
 }
@@ skipping 11 matching lines @@
 }
 
 void SearchTabHelper::RenderViewCreated(
     content::RenderViewHost* render_view_host) {
   ipc_router_.SetPromoInformation(IsAppLauncherEnabled());
 }
 
 void SearchTabHelper::DidStartNavigationToPendingEntry(
     const GURL& url,
     content::NavigationController::ReloadType /* reload_type */) {
-  if (chrome::IsNTPURL(url, profile())) {
+  if (search::IsNTPURL(url, profile())) {
     // Set the title on any pending entry corresponding to the NTP. This
     // prevents any flickering of the tab title.
     content::NavigationEntry* entry =
         web_contents_->GetController().GetPendingEntry();
     if (entry)
       entry->SetTitle(l10n_util::GetStringUTF16(IDS_NEW_TAB_TITLE));
   }
 }
 
 void SearchTabHelper::DidNavigateMainFrame(
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
   if (IsCacheableNTP(web_contents_)) {
     UMA_HISTOGRAM_ENUMERATION("InstantExtended.CacheableNTPLoad",
-                              chrome::CACHEABLE_NTP_LOAD_SUCCEEDED,
-                              chrome::CACHEABLE_NTP_LOAD_MAX);
+                              search::CACHEABLE_NTP_LOAD_SUCCEEDED,
+                              search::CACHEABLE_NTP_LOAD_MAX);
   }
 
   // Always set the title on the new tab page to be the one from our UI
   // resources. Normally, we set the title when we begin a NTP load, but it can
   // get reset in several places (like when you press Reload). This check
   // ensures that the title is properly set to the string defined by the Chrome
   // UI language (rather than the server language) in all cases.
   //
   // We only override the title when it's nonempty to allow the page to set the
   // title if it really wants. An empty title means to use the default. There's
   // also a race condition between this code and the page's SetTitle call which
   // this rule avoids.
   content::NavigationEntry* entry =
       web_contents_->GetController().GetLastCommittedEntry();
   if (entry && entry->GetTitle().empty() &&
       (entry->GetVirtualURL() == GURL(chrome::kChromeUINewTabURL) ||
-       chrome::NavEntryIsInstantNTP(web_contents_, entry))) {
+       search::NavEntryIsInstantNTP(web_contents_, entry))) {
     entry->SetTitle(l10n_util::GetStringUTF16(IDS_NEW_TAB_TITLE));
   }
 }
 
 void SearchTabHelper::DidFinishLoad(content::RenderFrameHost* render_frame_host,
                                     const GURL& /* validated_url */) {
   if (!render_frame_host->GetParent()) {
-    if (chrome::IsInstantNTP(web_contents_))
+    if (search::IsInstantNTP(web_contents_))
       RecordNewTabLoadTime(web_contents_);
 
     DetermineIfPageSupportsInstant();
   }
 }
 
 void SearchTabHelper::NavigationEntryCommitted(
     const content::LoadCommittedDetails& load_details) {
   if (!is_search_enabled_)
     return;
 
   if (!load_details.is_main_frame)
     return;
 
-  if (chrome::ShouldAssignURLToInstantRenderer(web_contents_->GetURL(),
+  if (search::ShouldAssignURLToInstantRenderer(web_contents_->GetURL(),
                                                profile())) {
     InstantService* instant_service =
         InstantServiceFactory::GetForProfile(profile());
     ipc_router_.SetOmniboxStartMargin(instant_service->omnibox_start_margin());
     ipc_router_.SetDisplayInstantResults();
   }
 
   UpdateMode(true, false);
 
   content::NavigationEntry* entry =
       web_contents_->GetController().GetVisibleEntry();
   DCHECK(entry);
 
   // Already determined the instant support state for this page, do not reset
   // the instant support state.
   if (load_details.is_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(),
+    search::SetInstantSupportStateInNavigationEntry(model_.instant_support(),
                                                     entry);
     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(),
+  search::SetInstantSupportStateInNavigationEntry(model_.instant_support(),
                                                   entry);
 
   if (InInstantProcess(profile(), web_contents_))
     ipc_router_.OnNavigationEntryCommitted();
 }
 
 void SearchTabHelper::OnInstantSupportDetermined(bool supports_instant) {
   InstantSupportChanged(supports_instant);
 }
 
@@ skipping 200 matching lines @@
 
 bool SearchTabHelper::IsInputInProgress() const {
   OmniboxView* omnibox = GetOmniboxView();
   return !model_.mode().is_ntp() && omnibox &&
       omnibox->model()->focus_state() == OMNIBOX_FOCUS_VISIBLE;
 }
 
 OmniboxView* SearchTabHelper::GetOmniboxView() const {
   return delegate_ ? delegate_->GetOmniboxView() : NULL;
 }