Add support to enable EmbeddedSearch API in Android Chrome search results page.

chrome/browser/search/search.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/search/search.h"
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
@@ skipping 35 matching lines @@
 namespace {
 
 // Configuration options for Embedded Search.
 // EmbeddedSearch field trials are named in such a way that we can parse out
 // the experiment configuration from the trial's group name in order to give
 // us maximum flexability in running experiments.
 // Field trial groups should be named things like "Group7 espv:2 instant:1".
 // The first token is always GroupN for some integer N, followed by a
 // space-delimited list of key:value pairs which correspond to these flags:
 const char kEmbeddedPageVersionFlagName[] = "espv";
-#if defined(OS_IOS) || defined(OS_ANDROID)
+#if defined(OS_IOS)
 const uint64 kEmbeddedPageVersionDefault = 1;
+#elif defined(OS_ANDROID)
+const uint64 kEmbeddedPageVersionDefault = 1;
+// Use this variant to enable EmbeddedSearch SearchBox API in the results page.
+const uint64 kEmbeddedPageVersionVariant = 2;
 #else
 const uint64 kEmbeddedPageVersionDefault = 2;
 #endif
 
 const char kHideVerbatimFlagName[] = "hide_verbatim";
 const char kPrefetchSearchResultsFlagName[] = "prefetch_results";
 const char kPrefetchSearchResultsOnSRP[] = "prefetch_results_srp";
 
 // Controls whether to reuse prerendered Instant Search base page to commit any
 // search query.
@@ skipping 184 matching lines @@
 
   // For security reasons, don't extract search terms if the page is not being
   // rendered in the privileged Instant renderer process. This is to protect
   // against a malicious page somehow scripting the search results page and
   // faking search terms in the URL. Random pages can't get into the Instant
   // renderer and scripting doesn't work cross-process, so if the page is in
   // the Instant process, we know it isn't being exploited.
   // Since iOS and Android doesn't use the instant framework, these checks are
   // disabled for the two platforms.
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
-#if !defined(OS_IOS) && !defined(OS_ANDROID)
-  if (!IsRenderedInInstantProcess(contents, profile) &&
+#if defined(OS_IOS)
+  bool check_renderer_process = false;
+#elif defined(OS_ANDROID)
+  bool check_renderer_process =
+      EmbeddedSearchPageVersion() == kEmbeddedPageVersionVariant;
+#else
+  bool check_renderer_process = true;
+#endif  // defined(OS_IOS)
+  if (check_renderer_process &&
+      !IsRenderedInInstantProcess(contents, profile) &&
       ((entry == contents->GetController().GetLastCommittedEntry()) ||
        !ShouldAssignURLToInstantRenderer(entry->GetURL(), profile)))
     return base::string16();
-#endif  // !defined(OS_IOS) && !defined(OS_ANDROID)
+
   // Check to see if search terms have already been extracted.
   base::string16 search_terms = GetSearchTermsFromNavigationEntry(entry);
   if (!search_terms.empty())
     return search_terms;
 
   if (!IsQueryExtractionAllowedForURL(profile, entry->GetVirtualURL()))
     return base::string16();
 
   // Otherwise, extract from the URL.
   return ExtractSearchTermsFromURL(profile, entry->GetVirtualURL());
@@ skipping 58 matching lines @@
   GURL url;
   NewTabURLState state;
 };
 
 }  // namespace
 
 // Negative start-margin values prevent the "es_sm" parameter from being used.
 const int kDisableStartMargin = -1;
 
 bool IsInstantExtendedAPIEnabled() {
-#if defined(OS_IOS) || defined(OS_ANDROID)
+#if defined(OS_IOS)
   return false;
+#elif defined(OS_ANDROID)
+  return EmbeddedSearchPageVersion() == kEmbeddedPageVersionVariant;
 #else
   return true;
-#endif  // defined(OS_IOS) || defined(OS_ANDROID)
+#endif  // defined(OS_IOS)
 }
 
 // Determine what embedded search page version to request from the user's
 // default search provider. If 0, the embedded search UI should not be enabled.
 uint64 EmbeddedSearchPageVersion() {
+#if defined(OS_ANDROID)
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableEmbeddedSearchAPI)) {

[Ted C, 2014/04/24 16:24:13]

I believe this should be indented 4 from the if not from CommandLine

[kmadhusu, 2014/04/24 17:38:48]

Done.

+    return kEmbeddedPageVersionVariant;
+  }
+#endif
+
   FieldTrialFlags flags;
   if (GetFieldTrialInfo(&flags)) {
     return GetUInt64ValueForFlagWithDefault(kEmbeddedPageVersionFlagName,
                                             kEmbeddedPageVersionDefault,
                                             flags);
   }
   return kEmbeddedPageVersionDefault;
 }
 
 std::string InstantExtendedEnabledParam(bool for_search) {
@@ skipping 57 matching lines @@
 
 base::string16 GetSearchTerms(const content::WebContents* contents) {
   if (!contents)
     return base::string16();
 
   const content::NavigationEntry* entry =
       contents->GetController().GetVisibleEntry();
   if (!entry)
     return base::string16();
 
-#if !defined(OS_IOS) && !defined(OS_ANDROID)
-  // iOS and Android doesn't use the Instant framework, disable this check for
-  // the two platforms.
-  InstantSupportState state = GetInstantSupportStateFromNavigationEntry(*entry);
-  if (state == INSTANT_SUPPORT_NO)
-    return base::string16();
-#endif  // !defined(OS_IOS) && !defined(OS_ANDROID)
+  if (IsInstantExtendedAPIEnabled()) {
+    InstantSupportState state =
+        GetInstantSupportStateFromNavigationEntry(*entry);
+    if (state == INSTANT_SUPPORT_NO)
+      return base::string16();
+  }
 
   return GetSearchTermsImpl(contents, entry);
 }
 
 bool ShouldAssignURLToInstantRenderer(const GURL& url, Profile* profile) {
   return url.is_valid() &&
          profile &&
          IsInstantExtendedAPIEnabled() &&
          (url.SchemeIs(chrome::kChromeSearchScheme) ||
           IsInstantURL(url, profile));
@@ skipping 379 matching lines @@
 
 // Given a FieldTrialFlags object, returns the boolean value of the provided
 // flag.
 bool GetBoolValueForFlagWithDefault(const std::string& flag,
                                     bool default_value,
                                     const FieldTrialFlags& flags) {
   return !!GetUInt64ValueForFlagWithDefault(flag, default_value ? 1 : 0, flags);
 }
 
 }  // namespace chrome