Formatting fix.

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 114 matching lines @@
 
 void RecordInstantExtendedOptInState(OptInState state) {
   static bool recorded = false;
   if (!recorded) {
     recorded = true;
     UMA_HISTOGRAM_ENUMERATION("InstantExtended.OptInState", state,
                               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)) {
+    RecordInstantExtendedOptInState(OPT_OUT);
+    return kEmbeddedPageVersionDisabled;
+  }
+  if (command_line->HasSwitch(switches::kEnableInstantExtendedAPI)) {
+    // The user has set the about:flags switch to Enabled - give the default
+    // UI version.
+    RecordInstantExtendedOptInState(OPT_IN);
+    return kEmbeddedPageVersionDefault;
+  }
+
+  RecordInstantExtendedOptInState(NOT_SET);
+  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;
@@ skipping 17 matching lines @@
 
 }  // 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
-  // On desktop, query extraction is part of Instant extended, so if one is
-  // enabled, the other is too.
-  return IsQueryExtractionEnabled() || IsLocalOnlyInstantExtendedAPIEnabled();
+  // TODO(dougw): Switch to EmbeddedSearchPageVersion after the proper
+  // solution to Issue 232065 has been implemented.
+  return EmbeddedSearchPageVersionHelper() ||
+      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() {
-  // No server-side changes if the local-only Instant Extended is enabled.
-  if (IsLocalOnlyInstantExtendedAPIEnabled())
+uint64 EmbeddedSearchPageVersion(Profile* profile) {
+  // Disable for incognito. Temporary fix for Issue 232065.
+#if !defined(OS_IOS) && !defined(OS_ANDROID)
+  if (profile && profile->IsOffTheRecord())
     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)) {
-    RecordInstantExtendedOptInState(OPT_OUT);
-    return kEmbeddedPageVersionDisabled;
-  }
-  if (command_line->HasSwitch(switches::kEnableInstantExtendedAPI)) {
-    // The user has set the about:flags switch to Enabled - give the default
-    // UI version.
-    RecordInstantExtendedOptInState(OPT_IN);
-    return kEmbeddedPageVersionDefault;
-  }
-
-  RecordInstantExtendedOptInState(NOT_SET);
-  FieldTrialFlags flags;
-  if (GetFieldTrialInfo(
-          base::FieldTrialList::FindFullName(kInstantExtendedFieldTrialName),
-          &flags, NULL)) {
-    return GetUInt64ValueForFlagWithDefault(kEmbeddedPageVersionFlagName,
-                                            kEmbeddedPageVersionDefault,
-                                            flags);
-  }
-  return kEmbeddedPageVersionDisabled;
+#endif  // !defined(OS_IOS) && !defined(OS_ANDROID)
+  return EmbeddedSearchPageVersionHelper();
 }
 
-bool IsQueryExtractionEnabled() {
-  return EmbeddedSearchPageVersion() != kEmbeddedPageVersionDisabled;
+bool IsQueryExtractionEnabled(Profile* profile) {
+  return EmbeddedSearchPageVersion(profile) != kEmbeddedPageVersionDisabled;
 }
 
 bool IsLocalOnlyInstantExtendedAPIEnabled() {
   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))
     return true;
 
@@ skipping 332 matching lines @@
 
   GURL instant_url = TemplateURLRefToGURL(template_url->instant_url_ref(),
                                           kDisableStartMargin);
   // Extended mode instant requires a search terms replacement key.
   return instant_url.is_valid() &&
          (!IsInstantExtendedAPIEnabled() ||
           template_url->HasSearchTermsReplacementKey(instant_url));
 }
 
 }  // namespace chrome