InstantExtended: hook up InstantTab in incognito.

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 131 matching lines @@
       state = INSTANT_EXTENDED_OPT_IN_LOCAL;
     } else if (command_line->HasSwitch(switches::kEnableInstantExtendedAPI)) {
       state = INSTANT_EXTENDED_OPT_IN;
     }
 
     UMA_HISTOGRAM_ENUMERATION("InstantExtended.OptInState", state,
                               INSTANT_EXTENDED_OPT_IN_STATE_ENUM_COUNT);
   }
 }
 
-// Helper for EmbeddedSearchPageVersion. Does not check if in incognito mode.
-uint64 EmbeddedSearchPageVersionHelper() {
-  // No server-side changes if the local-only Instant Extended is enabled.
-  if (IsLocalOnlyInstantExtendedAPIEnabled())
-    return kEmbeddedPageVersionDisabled;
-
-  // Check the command-line/about:flags setting first, which should have
-  // precedence and allows the trial to not be reported (if it's never queried).
-  const CommandLine* command_line = CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(switches::kDisableInstantExtendedAPI))
-    return kEmbeddedPageVersionDisabled;
-  if (command_line->HasSwitch(switches::kEnableInstantExtendedAPI)) {
-    // The user has set the about:flags switch to Enabled - give the default
-    // UI version.
-    return kEmbeddedPageVersionDefault;
-  }
-
-  FieldTrialFlags flags;
-  if (GetFieldTrialInfo(
-          base::FieldTrialList::FindFullName(kInstantExtendedFieldTrialName),
-          &flags, NULL)) {
-    return GetUInt64ValueForFlagWithDefault(kEmbeddedPageVersionFlagName,
-                                            kEmbeddedPageVersionDefault,
-                                            flags);
-  }
-  return kEmbeddedPageVersionDisabled;
-}
-
 // Returns true if |contents| is rendered inside the Instant process for
 // |profile|.
 bool IsRenderedInInstantProcess(const content::WebContents* contents,
                                 Profile* profile) {
   const content::RenderProcessHost* process_host =
       contents->GetRenderProcessHost();
   if (!process_host)
     return false;
 
   const InstantService* instant_service =
@@ skipping 37 matching lines @@
     return true;
 
   if (extended_api_enabled && MatchesAnySearchURL(effective_url, template_url))
     return true;
 
   return false;
 }
 
 string16 GetSearchTermsImpl(const content::WebContents* contents,
                             const content::NavigationEntry* entry) {
+  if (!IsQueryExtractionEnabled())
+    return string16();
+
   // 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 (!IsQueryExtractionEnabled(profile))
-    return string16();
-
 #if !defined(OS_IOS) && !defined(OS_ANDROID)
   if (!IsRenderedInInstantProcess(contents, profile) &&
       (contents->GetController().GetLastCommittedEntry() == entry ||
        !ShouldAssignURLToInstantRenderer(entry->GetURL(), profile)))
     return string16();
 #endif  // !defined(OS_IOS) && !defined(OS_ANDROID)
   // Check to see if search terms have already been extracted.
   string16 search_terms = GetSearchTermsFromNavigationEntry(entry);
   if (!search_terms.empty())
     return search_terms;
 
   // Otherwise, extract from the URL.
   return GetSearchTermsFromURL(profile, entry->GetVirtualURL());
 }
 
 }  // 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)
   return false;
 #else
-  // TODO(dougw): Switch to EmbeddedSearchPageVersion after the proper
-  // solution to Issue 232065 has been implemented.
-  return EmbeddedSearchPageVersionHelper() ||
-      IsLocalOnlyInstantExtendedAPIEnabled();
+  // On desktop, query extraction is part of Instant extended, so if one is
+  // enabled, the other is too.
+  return IsQueryExtractionEnabled() || IsLocalOnlyInstantExtendedAPIEnabled();
 #endif  // defined(OS_IOS) || defined(OS_ANDROID)
 }
 
 // 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(Profile* profile) {
-  // Disable for incognito. Temporary fix for Issue 232065.
-#if !defined(OS_IOS) && !defined(OS_ANDROID)
-  if (!profile || profile->IsOffTheRecord())
+uint64 EmbeddedSearchPageVersion() {
+  // No server-side changes if the local-only Instant Extended is enabled.
+  if (IsLocalOnlyInstantExtendedAPIEnabled())
     return kEmbeddedPageVersionDisabled;
-#endif  // !defined(OS_IOS) && !defined(OS_ANDROID)
-  return EmbeddedSearchPageVersionHelper();
+
+  // Check the command-line/about:flags setting first, which should have
+  // precedence and allows the trial to not be reported (if it's never queried).
+  const CommandLine* command_line = CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kDisableInstantExtendedAPI))
+    return kEmbeddedPageVersionDisabled;
+  if (command_line->HasSwitch(switches::kEnableInstantExtendedAPI)) {
+    // The user has set the about:flags switch to Enabled - give the default
+    // UI version.
+    return kEmbeddedPageVersionDefault;
+  }
+
+  FieldTrialFlags flags;
+  if (GetFieldTrialInfo(
+          base::FieldTrialList::FindFullName(kInstantExtendedFieldTrialName),
+          &flags, NULL)) {
+    return GetUInt64ValueForFlagWithDefault(kEmbeddedPageVersionFlagName,
+                                            kEmbeddedPageVersionDefault,
+                                            flags);
+  }
+  return kEmbeddedPageVersionDisabled;
 }
 
-bool IsQueryExtractionEnabled(Profile* profile) {
-  return EmbeddedSearchPageVersion(profile) != kEmbeddedPageVersionDisabled;
+bool IsQueryExtractionEnabled() {
+  return EmbeddedSearchPageVersion() != kEmbeddedPageVersionDisabled;
 }
 
 bool IsLocalOnlyInstantExtendedAPIEnabled() {
   RecordInstantExtendedOptInState();
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kDisableLocalOnlyInstantExtendedAPI) ||
       command_line->HasSwitch(switches::kDisableInstantExtendedAPI)) {
     return false;
   }
   if (command_line->HasSwitch(switches::kEnableLocalOnlyInstantExtendedAPI))
@@ skipping 450 matching lines @@
   for (size_t i = 0; i < items_b.size(); ++i) {
     if (items_b[i].url != items_a[i].url ||
         items_b[i].title != items_a[i].title) {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace chrome