search: Log when bookmark bar is pinned.

chrome/browser/search_engines/template_url.cc

 // Copyright (c) 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_engines/template_url.h"
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/format_macros.h"
 #include "base/guid.h"
 #include "base/i18n/case_conversion.h"
 #include "base/i18n/icu_string_conversions.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/rand_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/google/google_util.h"
+#include "chrome/browser/search/search.h"
 #include "chrome/browser/search_engines/search_terms_data.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/url_constants.h"
 #include "extensions/common/constants.h"
 #include "google_apis/google_api_keys.h"
 #include "net/base/escape.h"
 #include "net/base/mime_util.h"
 #include "ui/base/l10n/l10n_util.h"
@@ skipping 20 matching lines @@
 
 const char kGoogleAssistedQueryStatsParameter[] = "google:assistedQueryStats";
 
 // Host/Domain Google searches are relative to.
 const char kGoogleBaseURLParameter[] = "google:baseURL";
 const char kGoogleBaseURLParameterFull[] = "{google:baseURL}";
 
 // Like google:baseURL, but for the Search Suggest capability.
 const char kGoogleBaseSuggestURLParameter[] = "google:baseSuggestURL";
 const char kGoogleBaseSuggestURLParameterFull[] = "{google:baseSuggestURL}";
+const char kGoogleBookmarkBarPinnedParameter[] = "google:bookmarkBarPinned";
 const char kGoogleCursorPositionParameter[] = "google:cursorPosition";
 const char kGoogleInstantEnabledParameter[] = "google:instantEnabledParameter";
 const char kGoogleInstantExtendedEnabledParameter[] =
     "google:instantExtendedEnabledParameter";
 const char kGoogleInstantExtendedEnabledKey[] =
     "google:instantExtendedEnabledKey";
 const char kGoogleInstantExtendedEnabledKeyFull[] =
     "{google:instantExtendedEnabledKey}";
 const char kGoogleNTPIsThemedParameter[] = "google:ntpIsThemedParameter";
 const char kGoogleOmniboxStartMarginParameter[] =
@@ skipping 102 matching lines @@
     return version;
   }
   return "unknown";
 }
 
 bool IsTemplateParameterString(const std::string& param) {
   return (param.length() > 2) && (*(param.begin()) == kStartParameter) &&
       (*(param.rbegin()) == kEndParameter);
 }
 
+bool ShowingSearchTermsOnSRP() {
+  return chrome::IsInstantExtendedAPIEnabled() &&
+      !chrome::ShouldSuppressInstantExtendedOnSRP();
+}
+
 }  // namespace
 
 
 // TemplateURLRef::SearchTermsArgs --------------------------------------------
 
 TemplateURLRef::SearchTermsArgs::SearchTermsArgs(const string16& search_terms)
     : search_terms(search_terms),
       accepted_suggestion(NO_SUGGESTIONS_AVAILABLE),
       cursor_position(string16::npos),
       omnibox_start_margin(-1),
       page_classification(AutocompleteInput::INVALID_SPEC),
+      bookmark_bar_pinned(false),
       append_extra_query_params(false) {
 }
 
 TemplateURLRef::SearchTermsArgs::~SearchTermsArgs() {
 }
 
 
 // TemplateURLRef -------------------------------------------------------------
 
 TemplateURLRef::TemplateURLRef(TemplateURL* owner, Type type)
     : owner_(owner),
       type_(type),
       index_in_owner_(-1),
       parsed_(false),
       valid_(false),
       supports_replacements_(false),
       search_term_key_location_(url_parse::Parsed::QUERY),
-      prepopulated_(false) {
+      prepopulated_(false),
+      showing_search_terms_(ShowingSearchTermsOnSRP()) {
   DCHECK(owner_);
   DCHECK_NE(INDEXED, type_);
 }
 
 TemplateURLRef::TemplateURLRef(TemplateURL* owner, size_t index_in_owner)
     : owner_(owner),
       type_(INDEXED),
       index_in_owner_(index_in_owner),
       parsed_(false),
       valid_(false),
       supports_replacements_(false),
       search_term_key_location_(url_parse::Parsed::QUERY),
-      prepopulated_(false) {
+      prepopulated_(false),
+      showing_search_terms_(ShowingSearchTermsOnSRP()) {
   DCHECK(owner_);
   DCHECK_LT(index_in_owner_, owner_->URLCount());
 }
 
 TemplateURLRef::~TemplateURLRef() {
 }
 
 std::string TemplateURLRef::GetURL() const {
   switch (type_) {
     case SEARCH:  return owner_->url();
@@ skipping 292 matching lines @@
     replacements->push_back(Replacement(SEARCH_TERMS, start));
   } else if (parameter == kCountParameter) {
     if (!optional)
       url->insert(start, kDefaultCount);
   } else if (parameter == kGoogleAssistedQueryStatsParameter) {
     replacements->push_back(Replacement(GOOGLE_ASSISTED_QUERY_STATS, start));
   } else if (parameter == kGoogleBaseURLParameter) {
     replacements->push_back(Replacement(GOOGLE_BASE_URL, start));
   } else if (parameter == kGoogleBaseSuggestURLParameter) {
     replacements->push_back(Replacement(GOOGLE_BASE_SUGGEST_URL, start));
+  } else if (parameter == kGoogleBookmarkBarPinnedParameter) {
+    replacements->push_back(Replacement(GOOGLE_BOOKMARK_BAR_PINNED, start));
   } else if (parameter == kGoogleCursorPositionParameter) {
     replacements->push_back(Replacement(GOOGLE_CURSOR_POSITION, start));
   } else if (parameter == kGoogleImageOriginalHeight) {
     replacements->push_back(
         Replacement(TemplateURLRef::GOOGLE_IMAGE_ORIGINAL_HEIGHT, start));
   } else if (parameter == kGoogleImageOriginalWidth) {
     replacements->push_back(
         Replacement(TemplateURLRef::GOOGLE_IMAGE_ORIGINAL_WIDTH, start));
   } else if (parameter == kGoogleImageSearchSource) {
     url->insert(start, GetGoogleImageSearchSource());
@@ skipping 272 matching lines @@
             std::string(), search_terms_data.GoogleBaseURLValue(), *i, &url);
         break;
 
       case GOOGLE_BASE_SUGGEST_URL:
         DCHECK(!i->is_post_param);
         HandleReplacement(
             std::string(), search_terms_data.GoogleBaseSuggestURLValue(), *i,
             &url);
         break;
 
+      case GOOGLE_BOOKMARK_BAR_PINNED:
+        if (showing_search_terms_) {
+          // Log whether the bookmark bar is pinned when the user is seeing
+          // InstantExtended on the SRP.
+          DCHECK(!i->is_post_param);
+          HandleReplacement(
+              "bmbp", search_terms_args.bookmark_bar_pinned ? "1" : "0", *i,
+              &url);
+        }
+        break;
+
       case GOOGLE_CURSOR_POSITION:
         DCHECK(!i->is_post_param);
         if (search_terms_args.cursor_position != string16::npos)
           HandleReplacement(
               "cp",
               base::StringPrintf("%" PRIuS, search_terms_args.cursor_position),
               *i,
               &url);
         break;
 
@@ skipping 437 matching lines @@
       // patterns. This means that given patterns
       //    [ "http://foo/#q={searchTerms}", "http://foo/?q={searchTerms}" ],
       // calling ExtractSearchTermsFromURL() on "http://foo/?q=bar#q=' would
       // return false. This is important for at least Google, where such URLs
       // are invalid.
       return !search_terms->empty();
     }
   }
   return false;
 }