chrome/browser/search/search.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/search/search.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/metrics/field_trial.h"
   9 #include "base/metrics/histogram.h"
  10 #include "base/prefs/pref_service.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "base/strings/string_split.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "chrome/browser/browser_process.h"
  15 #include "chrome/browser/profiles/profile.h"
  16 #include "chrome/browser/profiles/profile_manager.h"
  17 #include "chrome/browser/search/instant_service.h"
  18 #include "chrome/browser/search/instant_service_factory.h"
  19 #include "chrome/browser/search_engines/template_url_service_factory.h"
  20 #include "chrome/browser/search_engines/ui_thread_search_terms_data.h"
  21 #include "chrome/browser/ui/browser.h"
  22 #include "chrome/browser/ui/browser_instant_controller.h"
  23 #include "chrome/browser/ui/browser_iterator.h"
  24 #include "chrome/browser/ui/search/instant_search_prerenderer.h"
  25 #include "chrome/common/chrome_switches.h"
  26 #include "chrome/common/pref_names.h"
  27 #include "chrome/common/search_urls.h"
  28 #include "chrome/common/url_constants.h"
  29 #include "components/google/core/browser/google_util.h"
  30 #include "components/pref_registry/pref_registry_syncable.h"
  31 #include "components/search/search.h"
  32 #include "components/search_engines/template_url_service.h"
  33 #include "components/sessions/serialized_navigation_entry.h"
  34 #include "content/public/browser/navigation_entry.h"
  35 #include "content/public/browser/render_process_host.h"
  36 #include "content/public/browser/web_contents.h"
  37
  38 #if defined(ENABLE_MANAGED_USERS)
  39 #include "chrome/browser/supervised_user/supervised_user_service.h"
  40 #include "chrome/browser/supervised_user/supervised_user_service_factory.h"
  41 #include "chrome/browser/supervised_user/supervised_user_url_filter.h"
  42 #endif
  43
  44 namespace chrome {
  45
  46 namespace {
  47
  48 const char kPrefetchSearchResultsOnSRP[] = "prefetch_results_srp";
  49 const char kAllowPrefetchNonDefaultMatch[] = "allow_prefetch_non_default_match";
  50 const char kPrerenderInstantUrlOnOmniboxFocus[] =
  51     "prerender_instant_url_on_omnibox_focus";
  52
  53 #if defined(OS_ANDROID)
  54 const char kPrefetchSearchResultsFlagName[] = "prefetch_results";
  55
  56 // Controls whether to reuse prerendered Instant Search base page to commit any
  57 // search query.
  58 const char kReuseInstantSearchBasePage[] = "reuse_instant_search_base_page";
  59 #endif
  60
  61 // Controls whether to use the alternate Instant search base URL. This allows
  62 // experimentation of Instant search.
  63 const char kUseAltInstantURL[] = "use_alternate_instant_url";
  64 const char kUseSearchPathForInstant[] = "use_search_path_for_instant";
  65 const char kAltInstantURLPath[] = "search";
  66 const char kAltInstantURLQueryParams[] = "&qbp=1";
  67
  68 const char kDisplaySearchButtonFlagName[] = "display_search_button";
  69 const char kOriginChipFlagName[] = "origin_chip";
  70 #if !defined(OS_IOS) && !defined(OS_ANDROID)
  71 const char kEnableQueryExtractionFlagName[] = "query_extraction";
  72 #endif
  73 const char kShouldShowGoogleLocalNTPFlagName[] = "google_local_ntp";
  74
  75 // Status of the New Tab URL for the default Search provider. NOTE: Used in a
  76 // UMA histogram so values should only be added at the end and not reordered.
  77 enum NewTabURLState {
  78   // Valid URL that should be used.
  79   NEW_TAB_URL_VALID = 0,
  80
  81   // Corrupt state (e.g. no profile or template url).
  82   NEW_TAB_URL_BAD = 1,
  83
  84   // URL should not be used because in incognito window.
  85   NEW_TAB_URL_INCOGNITO = 2,
  86
  87   // No New Tab URL set for provider.
  88   NEW_TAB_URL_NOT_SET = 3,
  89
  90   // URL is not secure.
  91   NEW_TAB_URL_INSECURE = 4,
  92
  93   // URL should not be used because Suggest is disabled.
  94   // Not used anymore, see crbug.com/340424.
  95   // NEW_TAB_URL_SUGGEST_OFF = 5,
  96
  97   // URL should not be used because it is blocked for a supervised user.
  98   NEW_TAB_URL_BLOCKED = 6,
  99
 100   NEW_TAB_URL_MAX
 101 };
 102
 103 // Used to set the Instant support state of the Navigation entry.
 104 const char kInstantSupportStateKey[] = "instant_support_state";
 105
 106 const char kInstantSupportEnabled[] = "Instant support enabled";
 107 const char kInstantSupportDisabled[] = "Instant support disabled";
 108 const char kInstantSupportUnknown[] = "Instant support unknown";
 109
 110 InstantSupportState StringToInstantSupportState(const base::string16& value) {
 111   if (value == base::ASCIIToUTF16(kInstantSupportEnabled))
 112     return INSTANT_SUPPORT_YES;
 113   else if (value == base::ASCIIToUTF16(kInstantSupportDisabled))
 114     return INSTANT_SUPPORT_NO;
 115   else
 116     return INSTANT_SUPPORT_UNKNOWN;
 117 }
 118
 119 base::string16 InstantSupportStateToString(InstantSupportState state) {
 120   switch (state) {
 121     case INSTANT_SUPPORT_NO:
 122       return base::ASCIIToUTF16(kInstantSupportDisabled);
 123     case INSTANT_SUPPORT_YES:
 124       return base::ASCIIToUTF16(kInstantSupportEnabled);
 125     case INSTANT_SUPPORT_UNKNOWN:
 126       return base::ASCIIToUTF16(kInstantSupportUnknown);
 127   }
 128   return base::ASCIIToUTF16(kInstantSupportUnknown);
 129 }
 130
 131 TemplateURL* GetDefaultSearchProviderTemplateURL(Profile* profile) {
 132   if (profile) {
 133     TemplateURLService* template_url_service =
 134         TemplateURLServiceFactory::GetForProfile(profile);
 135     if (template_url_service)
 136       return template_url_service->GetDefaultSearchProvider();
 137   }
 138   return NULL;
 139 }
 140
 141 GURL TemplateURLRefToGURL(const TemplateURLRef& ref,
 142                           const SearchTermsData& search_terms_data,
 143                           bool append_extra_query_params,
 144                           bool force_instant_results) {
 145   TemplateURLRef::SearchTermsArgs search_terms_args =
 146       TemplateURLRef::SearchTermsArgs(base::string16());
 147   search_terms_args.append_extra_query_params = append_extra_query_params;
 148   search_terms_args.force_instant_results = force_instant_results;
 149   return GURL(ref.ReplaceSearchTerms(search_terms_args, search_terms_data));
 150 }
 151
 152 bool MatchesAnySearchURL(const GURL& url,
 153                          TemplateURL* template_url,
 154                          const SearchTermsData& search_terms_data) {
 155   GURL search_url = TemplateURLRefToGURL(template_url->url_ref(),
 156                                          search_terms_data, false, false);
 157   if (search_url.is_valid() &&
 158       search::MatchesOriginAndPath(url, search_url))
 159     return true;
 160
 161   // "URLCount() - 1" because we already tested url_ref above.
 162   for (size_t i = 0; i < template_url->URLCount() - 1; ++i) {
 163     TemplateURLRef ref(template_url, i);
 164     search_url = TemplateURLRefToGURL(ref, search_terms_data, false, false);
 165     if (search_url.is_valid() &&
 166         search::MatchesOriginAndPath(url, search_url))
 167       return true;
 168   }
 169
 170   return false;
 171 }
 172
 173
 174
 175 // |url| should either have a secure scheme or have a non-HTTPS base URL that
 176 // the user specified using --google-base-url. (This allows testers to use
 177 // --google-base-url to point at non-HTTPS servers, which eases testing.)
 178 bool IsSuitableURLForInstant(const GURL& url, const TemplateURL* template_url) {
 179   return template_url->HasSearchTermsReplacementKey(url) &&
 180       (url.SchemeIsSecure() ||
 181        google_util::StartsWithCommandLineGoogleBaseURL(url));
 182 }
 183
 184 // Returns true if |url| can be used as an Instant URL for |profile|.
 185 bool IsInstantURL(const GURL& url, Profile* profile) {
 186   if (!IsInstantExtendedAPIEnabled())
 187     return false;
 188
 189   if (!url.is_valid())
 190     return false;
 191
 192   const GURL new_tab_url(GetNewTabPageURL(profile));
 193   if (new_tab_url.is_valid() &&
 194       search::MatchesOriginAndPath(url, new_tab_url))
 195     return true;
 196
 197   TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
 198   if (!template_url)
 199     return false;
 200
 201   if (!IsSuitableURLForInstant(url, template_url))
 202     return false;
 203
 204   const TemplateURLRef& instant_url_ref = template_url->instant_url_ref();
 205   UIThreadSearchTermsData search_terms_data(profile);
 206   const GURL instant_url = TemplateURLRefToGURL(
 207       instant_url_ref, search_terms_data, false, false);
 208   if (!instant_url.is_valid())
 209     return false;
 210
 211   if (search::MatchesOriginAndPath(url, instant_url))
 212     return true;
 213
 214   return IsQueryExtractionEnabled() &&
 215       MatchesAnySearchURL(url, template_url, search_terms_data);
 216 }
 217
 218 base::string16 GetSearchTermsImpl(const content::WebContents* contents,
 219                                   const content::NavigationEntry* entry) {
 220   if (!contents || !IsQueryExtractionEnabled())
 221     return base::string16();
 222
 223   // For security reasons, don't extract search terms if the page is not being
 224   // rendered in the privileged Instant renderer process. This is to protect
 225   // against a malicious page somehow scripting the search results page and
 226   // faking search terms in the URL. Random pages can't get into the Instant
 227   // renderer and scripting doesn't work cross-process, so if the page is in
 228   // the Instant process, we know it isn't being exploited.
 229   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
 230   if (IsInstantExtendedAPIEnabled() &&
 231       !IsRenderedInInstantProcess(contents, profile) &&
 232       ((entry == contents->GetController().GetLastCommittedEntry()) ||
 233        !ShouldAssignURLToInstantRenderer(entry->GetURL(), profile)))
 234     return base::string16();
 235
 236   // Check to see if search terms have already been extracted.
 237   base::string16 search_terms = GetSearchTermsFromNavigationEntry(entry);
 238   if (!search_terms.empty())
 239     return search_terms;
 240
 241   if (!IsQueryExtractionAllowedForURL(profile, entry->GetVirtualURL()))
 242     return base::string16();
 243
 244   // Otherwise, extract from the URL.
 245   return ExtractSearchTermsFromURL(profile, entry->GetVirtualURL());
 246 }
 247
 248 bool IsURLAllowedForSupervisedUser(const GURL& url, Profile* profile) {
 249 #if defined(ENABLE_MANAGED_USERS)
 250   SupervisedUserService* supervised_user_service =
 251       SupervisedUserServiceFactory::GetForProfile(profile);
 252   SupervisedUserURLFilter* url_filter =
 253       supervised_user_service->GetURLFilterForUIThread();
 254   if (url_filter->GetFilteringBehaviorForURL(url) ==
 255           SupervisedUserURLFilter::BLOCK) {
 256     return false;
 257   }
 258 #endif
 259   return true;
 260 }
 261
 262 // Returns whether |new_tab_url| can be used as a URL for the New Tab page.
 263 // NEW_TAB_URL_VALID means a valid URL; other enum values imply an invalid URL.
 264 NewTabURLState IsValidNewTabURL(Profile* profile, const GURL& new_tab_url) {
 265   if (profile->IsOffTheRecord())
 266     return NEW_TAB_URL_INCOGNITO;
 267   if (!new_tab_url.is_valid())
 268     return NEW_TAB_URL_NOT_SET;
 269   if (!new_tab_url.SchemeIsSecure())
 270     return NEW_TAB_URL_INSECURE;
 271   if (!IsURLAllowedForSupervisedUser(new_tab_url, profile))
 272     return NEW_TAB_URL_BLOCKED;
 273   return NEW_TAB_URL_VALID;
 274 }
 275
 276 // Used to look up the URL to use for the New Tab page. Also tracks how we
 277 // arrived at that URL so it can be logged with UMA.
 278 struct NewTabURLDetails {
 279   NewTabURLDetails(const GURL& url, NewTabURLState state)
 280       : url(url), state(state) {}
 281
 282   static NewTabURLDetails ForProfile(Profile* profile) {
 283     const GURL local_url(chrome::kChromeSearchLocalNtpUrl);
 284     TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
 285     if (!profile || !template_url)
 286       return NewTabURLDetails(local_url, NEW_TAB_URL_BAD);
 287
 288     GURL search_provider_url = TemplateURLRefToGURL(
 289         template_url->new_tab_url_ref(), UIThreadSearchTermsData(profile),
 290         false, false);
 291     NewTabURLState state = IsValidNewTabURL(profile, search_provider_url);
 292     switch (state) {
 293       case NEW_TAB_URL_VALID:
 294         // We can use the search provider's page.
 295         return NewTabURLDetails(search_provider_url, state);
 296       case NEW_TAB_URL_INCOGNITO:
 297         // Incognito has its own New Tab.
 298         return NewTabURLDetails(GURL(), state);
 299       default:
 300         // Use the local New Tab otherwise.
 301         return NewTabURLDetails(local_url, state);
 302     }
 303   }
 304
 305   GURL url;
 306   NewTabURLState state;
 307 };
 308
 309 }  // namespace
 310
 311 // Negative start-margin values prevent the "es_sm" parameter from being used.
 312 const int kDisableStartMargin = -1;
 313
 314 std::string InstantExtendedEnabledParam(bool for_search) {
 315   if (for_search && !chrome::IsQueryExtractionEnabled())
 316     return std::string();
 317   return std::string(google_util::kInstantExtendedAPIParam) + "=" +
 318       base::Uint64ToString(EmbeddedSearchPageVersion()) + "&";
 319 }
 320
 321 std::string ForceInstantResultsParam(bool for_prerender) {
 322   return (for_prerender || !IsInstantExtendedAPIEnabled()) ?
 323       "ion=1&" : std::string();
 324 }
 325
 326 bool IsQueryExtractionEnabled() {
 327 #if defined(OS_IOS) || defined(OS_ANDROID)
 328   return true;
 329 #else
 330   if (!IsInstantExtendedAPIEnabled())
 331     return false;
 332
 333   const CommandLine* command_line = CommandLine::ForCurrentProcess();
 334   if (command_line->HasSwitch(switches::kEnableQueryExtraction))
 335     return true;
 336
 337   FieldTrialFlags flags;
 338   return GetFieldTrialInfo(&flags) && GetBoolValueForFlagWithDefault(
 339       kEnableQueryExtractionFlagName, false, flags);
 340 #endif  // defined(OS_IOS) || defined(OS_ANDROID)
 341 }
 342
 343 base::string16 ExtractSearchTermsFromURL(Profile* profile, const GURL& url) {
 344   if (url.is_valid() && url == GetSearchResultPrefetchBaseURL(profile)) {
 345     // InstantSearchPrerenderer has the search query for the Instant search base
 346     // page.
 347     InstantSearchPrerenderer* prerenderer =
 348         InstantSearchPrerenderer::GetForProfile(profile);
 349     // TODO(kmadhusu): Remove this CHECK after the investigation of
 350     // crbug.com/367204.
 351     CHECK(prerenderer);
 352     return prerenderer->get_last_query();
 353   }
 354
 355   TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
 356   base::string16 search_terms;
 357   if (template_url)
 358     template_url->ExtractSearchTermsFromURL(
 359         url, UIThreadSearchTermsData(profile), &search_terms);
 360   return search_terms;
 361 }
 362
 363 bool IsQueryExtractionAllowedForURL(Profile* profile, const GURL& url) {
 364   TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
 365   return template_url && IsSuitableURLForInstant(url, template_url);
 366 }
 367
 368 base::string16 GetSearchTermsFromNavigationEntry(
 369     const content::NavigationEntry* entry) {
 370   base::string16 search_terms;
 371   if (entry)
 372     entry->GetExtraData(sessions::kSearchTermsKey, &search_terms);
 373   return search_terms;
 374 }
 375
 376 base::string16 GetSearchTerms(const content::WebContents* contents) {
 377   if (!contents)
 378     return base::string16();
 379
 380   const content::NavigationEntry* entry =
 381       contents->GetController().GetVisibleEntry();
 382   if (!entry)
 383     return base::string16();
 384
 385   if (IsInstantExtendedAPIEnabled()) {
 386     InstantSupportState state =
 387         GetInstantSupportStateFromNavigationEntry(*entry);
 388     if (state == INSTANT_SUPPORT_NO)
 389       return base::string16();
 390   }
 391
 392   return GetSearchTermsImpl(contents, entry);
 393 }
 394
 395 bool ShouldAssignURLToInstantRenderer(const GURL& url, Profile* profile) {
 396   return url.is_valid() &&
 397          profile &&
 398          IsInstantExtendedAPIEnabled() &&
 399          (url.SchemeIs(chrome::kChromeSearchScheme) ||
 400           IsInstantURL(url, profile));
 401 }
 402
 403 bool IsRenderedInInstantProcess(const content::WebContents* contents,
 404                                 Profile* profile) {
 405   const content::RenderProcessHost* process_host =
 406       contents->GetRenderProcessHost();
 407   if (!process_host)
 408     return false;
 409
 410   const InstantService* instant_service =
 411       InstantServiceFactory::GetForProfile(profile);
 412   if (!instant_service)
 413     return false;
 414
 415   return instant_service->IsInstantProcess(process_host->GetID());
 416 }
 417
 418 bool ShouldUseProcessPerSiteForInstantURL(const GURL& url, Profile* profile) {
 419   return ShouldAssignURLToInstantRenderer(url, profile) &&
 420       (url.host() == chrome::kChromeSearchLocalNtpHost ||
 421        url.host() == chrome::kChromeSearchRemoteNtpHost);
 422 }
 423
 424 bool IsNTPURL(const GURL& url, Profile* profile) {
 425   if (!url.is_valid())
 426     return false;
 427
 428   if (!IsInstantExtendedAPIEnabled())
 429     return url == GURL(chrome::kChromeUINewTabURL);
 430
 431   const base::string16 search_terms = ExtractSearchTermsFromURL(profile, url);
 432   return profile &&
 433       ((IsInstantURL(url, profile) && search_terms.empty()) ||
 434        url == GURL(chrome::kChromeSearchLocalNtpUrl));
 435 }
 436
 437 bool IsInstantNTP(const content::WebContents* contents) {
 438   if (!contents)
 439     return false;
 440
 441   return NavEntryIsInstantNTP(contents,
 442                               contents->GetController().GetVisibleEntry());
 443 }
 444
 445 bool NavEntryIsInstantNTP(const content::WebContents* contents,
 446                           const content::NavigationEntry* entry) {
 447   if (!contents || !entry || !IsInstantExtendedAPIEnabled())
 448     return false;
 449
 450   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
 451   if (!IsRenderedInInstantProcess(contents, profile))
 452     return false;
 453
 454   if (entry->GetURL() == GetLocalInstantURL(profile))
 455     return true;
 456
 457   GURL new_tab_url(GetNewTabPageURL(profile));
 458   return new_tab_url.is_valid() &&
 459       search::MatchesOriginAndPath(entry->GetURL(), new_tab_url);
 460 }
 461
 462 bool IsSuggestPrefEnabled(Profile* profile) {
 463   return profile && !profile->IsOffTheRecord() && profile->GetPrefs() &&
 464          profile->GetPrefs()->GetBoolean(prefs::kSearchSuggestEnabled);
 465 }
 466
 467 GURL GetInstantURL(Profile* profile, bool force_instant_results) {
 468   if (!IsInstantExtendedAPIEnabled() || !IsSuggestPrefEnabled(profile))
 469     return GURL();
 470
 471   TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
 472   if (!template_url)
 473     return GURL();
 474
 475   GURL instant_url = TemplateURLRefToGURL(
 476       template_url->instant_url_ref(), UIThreadSearchTermsData(profile),
 477       true, force_instant_results);
 478   if (!instant_url.is_valid() ||
 479       !template_url->HasSearchTermsReplacementKey(instant_url))
 480     return GURL();
 481
 482   // Extended mode requires HTTPS.  Force it unless the base URL was overridden
 483   // on the command line, in which case we allow HTTP (see comments on
 484   // IsSuitableURLForInstant()).
 485   if (!instant_url.SchemeIsSecure() &&
 486       !google_util::StartsWithCommandLineGoogleBaseURL(instant_url)) {
 487     GURL::Replacements replacements;
 488     const std::string secure_scheme(url::kHttpsScheme);
 489     replacements.SetSchemeStr(secure_scheme);
 490     instant_url = instant_url.ReplaceComponents(replacements);
 491   }
 492
 493   if (!IsURLAllowedForSupervisedUser(instant_url, profile))
 494     return GURL();
 495
 496   if (ShouldUseAltInstantURL()) {
 497     GURL::Replacements replacements;
 498       const std::string path(
 499           ShouldUseSearchPathForInstant() ? kAltInstantURLPath : std::string());
 500     if (!path.empty())
 501       replacements.SetPathStr(path);
 502     const std::string query(
 503         instant_url.query() + std::string(kAltInstantURLQueryParams));
 504     replacements.SetQueryStr(query);
 505     instant_url = instant_url.ReplaceComponents(replacements);
 506   }
 507   return instant_url;
 508 }
 509
 510 // Returns URLs associated with the default search engine for |profile|.
 511 std::vector<GURL> GetSearchURLs(Profile* profile) {
 512   std::vector<GURL> result;
 513   TemplateURL* template_url = GetDefaultSearchProviderTemplateURL(profile);
 514   if (!template_url)
 515     return result;
 516   for (size_t i = 0; i < template_url->URLCount(); ++i) {
 517     TemplateURLRef ref(template_url, i);
 518     result.push_back(TemplateURLRefToGURL(ref, UIThreadSearchTermsData(profile),
 519                                           false, false));
 520   }
 521   return result;
 522 }
 523
 524 GURL GetNewTabPageURL(Profile* profile) {
 525   return NewTabURLDetails::ForProfile(profile).url;
 526 }
 527
 528 GURL GetSearchResultPrefetchBaseURL(Profile* profile) {
 529   return ShouldPrefetchSearchResults() ? GetInstantURL(profile, true) : GURL();
 530 }
 531
 532 bool ShouldPrefetchSearchResults() {
 533   if (!IsInstantExtendedAPIEnabled())
 534     return false;
 535
 536 #if defined(OS_ANDROID)
 537   if (CommandLine::ForCurrentProcess()->HasSwitch(
 538           switches::kPrefetchSearchResults)) {
 539     return true;
 540   }
 541
 542   FieldTrialFlags flags;
 543   return GetFieldTrialInfo(&flags) && GetBoolValueForFlagWithDefault(
 544       kPrefetchSearchResultsFlagName, false, flags);
 545 #else
 546   return true;
 547 #endif
 548 }
 549
 550 bool ShouldAllowPrefetchNonDefaultMatch() {
 551   if (!ShouldPrefetchSearchResults())
 552     return false;
 553
 554   FieldTrialFlags flags;
 555   return GetFieldTrialInfo(&flags) && GetBoolValueForFlagWithDefault(
 556       kAllowPrefetchNonDefaultMatch, false, flags);
 557 }
 558
 559 bool ShouldPrerenderInstantUrlOnOmniboxFocus() {
 560   if (!ShouldPrefetchSearchResults())
 561     return false;
 562
 563   FieldTrialFlags flags;
 564   return GetFieldTrialInfo(&flags) && GetBoolValueForFlagWithDefault(
 565       kPrerenderInstantUrlOnOmniboxFocus, false, flags);
 566 }
 567
 568 bool ShouldReuseInstantSearchBasePage() {
 569   if (!ShouldPrefetchSearchResults())
 570     return false;
 571
 572 #if defined(OS_ANDROID)
 573   FieldTrialFlags flags;
 574   return GetFieldTrialInfo(&flags) && GetBoolValueForFlagWithDefault(
 575       kReuseInstantSearchBasePage, false, flags);
 576 #else
 577   return true;
 578 #endif
 579 }
 580
 581 GURL GetLocalInstantURL(Profile* profile) {
 582   return GURL(chrome::kChromeSearchLocalNtpUrl);
 583 }
 584
 585 DisplaySearchButtonConditions GetDisplaySearchButtonConditions() {
 586   const CommandLine* cl = CommandLine::ForCurrentProcess();
 587   if (cl->HasSwitch(switches::kDisableSearchButtonInOmnibox))
 588     return DISPLAY_SEARCH_BUTTON_NEVER;
 589   if (cl->HasSwitch(switches::kEnableSearchButtonInOmniboxForStr))
 590     return DISPLAY_SEARCH_BUTTON_FOR_STR;
 591   if (cl->HasSwitch(switches::kEnableSearchButtonInOmniboxForStrOrIip))
 592     return DISPLAY_SEARCH_BUTTON_FOR_STR_OR_IIP;
 593   if (cl->HasSwitch(switches::kEnableSearchButtonInOmniboxAlways))
 594     return DISPLAY_SEARCH_BUTTON_ALWAYS;
 595
 596   FieldTrialFlags flags;
 597   if (!GetFieldTrialInfo(&flags))
 598     return DISPLAY_SEARCH_BUTTON_NEVER;
 599   uint64 value =
 600       GetUInt64ValueForFlagWithDefault(kDisplaySearchButtonFlagName, 0, flags);
 601   return (value < DISPLAY_SEARCH_BUTTON_NUM_VALUES) ?
 602       static_cast<DisplaySearchButtonConditions>(value) :
 603       DISPLAY_SEARCH_BUTTON_NEVER;
 604 }
 605
 606 bool ShouldDisplayOriginChip() {
 607   return GetOriginChipCondition() != ORIGIN_CHIP_DISABLED;
 608 }
 609
 610 OriginChipCondition GetOriginChipCondition() {
 611   const CommandLine* cl = CommandLine::ForCurrentProcess();
 612   if (cl->HasSwitch(switches::kDisableOriginChip))
 613     return ORIGIN_CHIP_DISABLED;
 614   if (cl->HasSwitch(switches::kEnableOriginChipAlways))
 615     return ORIGIN_CHIP_ALWAYS;
 616   if (cl->HasSwitch(switches::kEnableOriginChipOnSrp))
 617     return ORIGIN_CHIP_ON_SRP;
 618
 619   FieldTrialFlags flags;
 620   if (!GetFieldTrialInfo(&flags))
 621     return ORIGIN_CHIP_DISABLED;
 622   uint64 value =
 623       GetUInt64ValueForFlagWithDefault(kOriginChipFlagName, 0, flags);
 624   return (value < ORIGIN_CHIP_NUM_VALUES) ?
 625       static_cast<OriginChipCondition>(value) : ORIGIN_CHIP_DISABLED;
 626 }
 627
 628 bool ShouldShowGoogleLocalNTP() {
 629   FieldTrialFlags flags;
 630   return !GetFieldTrialInfo(&flags) || GetBoolValueForFlagWithDefault(
 631       kShouldShowGoogleLocalNTPFlagName, true, flags);
 632 }
 633
 634 GURL GetEffectiveURLForInstant(const GURL& url, Profile* profile) {
 635   CHECK(ShouldAssignURLToInstantRenderer(url, profile))
 636       << "Error granting Instant access.";
 637
 638   if (url.SchemeIs(chrome::kChromeSearchScheme))
 639     return url;
 640
 641   GURL effective_url(url);
 642
 643   // Replace the scheme with "chrome-search:".
 644   url::Replacements<char> replacements;
 645   std::string search_scheme(chrome::kChromeSearchScheme);
 646   replacements.SetScheme(search_scheme.data(),
 647                          url::Component(0, search_scheme.length()));
 648
 649   // If this is the URL for a server-provided NTP, replace the host with
 650   // "remote-ntp".
 651   std::string remote_ntp_host(chrome::kChromeSearchRemoteNtpHost);
 652   NewTabURLDetails details = NewTabURLDetails::ForProfile(profile);
 653   if (details.state == NEW_TAB_URL_VALID &&
 654       search::MatchesOriginAndPath(url, details.url)) {
 655     replacements.SetHost(remote_ntp_host.c_str(),
 656                          url::Component(0, remote_ntp_host.length()));
 657   }
 658
 659   effective_url = effective_url.ReplaceComponents(replacements);
 660   return effective_url;
 661 }
 662
 663 bool HandleNewTabURLRewrite(GURL* url,
 664                             content::BrowserContext* browser_context) {
 665   if (!IsInstantExtendedAPIEnabled())
 666     return false;
 667
 668   if (!url->SchemeIs(content::kChromeUIScheme) ||
 669       url->host() != chrome::kChromeUINewTabHost)
 670     return false;
 671
 672   Profile* profile = Profile::FromBrowserContext(browser_context);
 673   NewTabURLDetails details(NewTabURLDetails::ForProfile(profile));
 674   UMA_HISTOGRAM_ENUMERATION("NewTabPage.URLState",
 675                             details.state, NEW_TAB_URL_MAX);
 676   if (details.url.is_valid()) {
 677     *url = details.url;
 678     return true;
 679   }
 680   return false;
 681 }
 682
 683 bool HandleNewTabURLReverseRewrite(GURL* url,
 684                                    content::BrowserContext* browser_context) {
 685   if (!IsInstantExtendedAPIEnabled())
 686     return false;
 687
 688   // Do nothing in incognito.
 689   Profile* profile = Profile::FromBrowserContext(browser_context);
 690   if (profile && profile->IsOffTheRecord())
 691     return false;
 692
 693   if (search::MatchesOriginAndPath(
 694       GURL(chrome::kChromeSearchLocalNtpUrl), *url)) {
 695     *url = GURL(chrome::kChromeUINewTabURL);
 696     return true;
 697   }
 698
 699   GURL new_tab_url(GetNewTabPageURL(profile));
 700   if (new_tab_url.is_valid() &&
 701       search::MatchesOriginAndPath(new_tab_url, *url)) {
 702     *url = GURL(chrome::kChromeUINewTabURL);
 703     return true;
 704   }
 705
 706   return false;
 707 }
 708
 709 void SetInstantSupportStateInNavigationEntry(InstantSupportState state,
 710                                              content::NavigationEntry* entry) {
 711   if (!entry)
 712     return;
 713
 714   entry->SetExtraData(kInstantSupportStateKey,
 715                       InstantSupportStateToString(state));
 716 }
 717
 718 InstantSupportState GetInstantSupportStateFromNavigationEntry(
 719     const content::NavigationEntry& entry) {
 720   base::string16 value;
 721   if (!entry.GetExtraData(kInstantSupportStateKey, &value))
 722     return INSTANT_SUPPORT_UNKNOWN;
 723
 724   return StringToInstantSupportState(value);
 725 }
 726
 727 bool ShouldPrefetchSearchResultsOnSRP() {
 728   FieldTrialFlags flags;
 729   return GetFieldTrialInfo(&flags) && GetBoolValueForFlagWithDefault(
 730       kPrefetchSearchResultsOnSRP, false, flags);
 731 }
 732
 733 void EnableQueryExtractionForTesting() {
 734   CommandLine* cl = CommandLine::ForCurrentProcess();
 735   cl->AppendSwitch(switches::kEnableQueryExtraction);
 736 }
 737
 738 bool ShouldUseAltInstantURL() {
 739   FieldTrialFlags flags;
 740   return GetFieldTrialInfo(&flags) && GetBoolValueForFlagWithDefault(
 741       kUseAltInstantURL, false, flags);
 742 }
 743
 744 bool ShouldUseSearchPathForInstant() {
 745   FieldTrialFlags flags;
 746   return GetFieldTrialInfo(&flags) && GetBoolValueForFlagWithDefault(
 747       kUseSearchPathForInstant, false, flags);
 748 }
 749
 750 }  // namespace chrome