Move GoogleImageSearchSource() from template_url.cc to UIThreadSearchTermsData

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 <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/format_macros.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/template_url_service.h"
 #include "chrome/common/chrome_switches.h"
-#include "chrome/common/chrome_version_info.h"
 #include "components/metrics/proto/omnibox_input_type.pb.h"
 #include "components/search_engines/search_terms_data.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"
 
 namespace {
 
@@ skipping 123 matching lines @@
           std::string::npos ||
           value_string.find(kGoogleUnescapedSearchTermsParameterFull, 0) !=
           std::string::npos) {
         return params.substr(key.begin, key.len);
       }
     }
   }
   return std::string();
 }
 
-// Returns the string to use for replacements of type
-// GOOGLE_IMAGE_SEARCH_SOURCE.
-std::string GetGoogleImageSearchSource() {
-  chrome::VersionInfo version_info;
-  if (version_info.is_valid()) {
-    std::string version(version_info.Name() + " " + version_info.Version());
-    if (version_info.IsOfficialBuild())
-      version += " (Official)";
-    version += " " + version_info.OSType();
-    std::string modifier(version_info.GetVersionStringModifier());
-    if (!modifier.empty())
-      version += " " + modifier;
-    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::IsQueryExtractionEnabled();
 }
 
@@ skipping 387 matching lines @@
     replacements->push_back(Replacement(GOOGLE_CURSOR_POSITION, start));
   } else if (parameter == kGoogleForceInstantResultsParameter) {
     replacements->push_back(Replacement(GOOGLE_FORCE_INSTANT_RESULTS, 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());
+    replacements->push_back(
+        Replacement(TemplateURLRef::GOOGLE_IMAGE_SEARCH_SOURCE, start));
   } else if (parameter == kGoogleImageThumbnailParameter) {
     replacements->push_back(
         Replacement(TemplateURLRef::GOOGLE_IMAGE_THUMBNAIL, start));
   } else if (parameter == kGoogleImageURLParameter) {
     replacements->push_back(Replacement(TemplateURLRef::GOOGLE_IMAGE_URL,
                                         start));
   } else if (parameter == kGoogleInputTypeParameter) {
     replacements->push_back(Replacement(TemplateURLRef::GOOGLE_INPUT_TYPE,
                                         start));
   } else if (parameter == kGoogleInstantExtendedEnabledParameter) {
@@ skipping 500 matching lines @@
 
       case GOOGLE_IMAGE_ORIGINAL_HEIGHT:
         if (!search_terms_args.image_original_size.IsEmpty()) {
           HandleReplacement(
               std::string(),
               base::IntToString(search_terms_args.image_original_size.height()),
               *i, &url);
         }
         break;
 
+      case GOOGLE_IMAGE_SEARCH_SOURCE:
+        HandleReplacement(
+            std::string(), search_terms_data.GoogleImageSearchSource(), *i,
+            &url);
+        break;
+
       default:
         NOTREACHED();
         break;
     }
   }
 
   if (!post_params_.empty())
     EncodeFormData(post_params_, post_content);
 
   return url;
@@ skipping 283 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;
 }