Remove the "autogenerate keyword" bit on TemplateURL.

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/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/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete_field_trial.h"
+#include "chrome/browser/google/google_util.h"
 #include "chrome/browser/search_engines/search_terms_data.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/common/guid.h"
 #include "chrome/common/url_constants.h"
 #include "net/base/escape.h"
 #include "ui/base/l10n/l10n_util.h"
 
 // The TemplateURLRef has any number of terms that need to be replaced. Each of
 // the terms is enclosed in braces. If the character preceeding the final
 // brace is a ?, it indicates the term is optional and can be replaced with
@@ skipping 502 matching lines @@
 TemplateURLData::TemplateURLData()
     : show_in_default_list(false),
       safe_for_autoreplace(false),
       id(0),
       date_created(base::Time::Now()),
       last_modified(base::Time::Now()),
       created_by_policy(false),
       usage_count(0),
       prepopulate_id(0),
       sync_guid(guid::GenerateGUID()),
-      url_("x"),
-      autogenerate_keyword_(false),
-      keyword_generated_(false) {
+      keyword_(ASCIIToUTF16("dummy")),

[SteveT, 2012/05/07 18:17:47]

Kind of curious if we're guaranteed to replace this initial dummy value before
this TURL makes its way into a TemplateURLService.

[Peter Kasting, 2012/05/07 19:39:14]

We should be, just like with the URL field.  It's hard to do runtime checks of
this (since you can't ban "keyword == dummy") but I did audit everywhere as part
of writing this.

+      url_("x") {
 }
 
 TemplateURLData::~TemplateURLData() {
 }
 
 void TemplateURLData::SetKeyword(const string16& keyword) {
+  DCHECK(!keyword.empty());
+
   // Case sensitive keyword matching is confusing. As such, we force all
   // keywords to be lower case.
   keyword_ = base::i18n::ToLower(keyword);
-  autogenerate_keyword_ = false;
-}
-
-const string16& TemplateURLData::keyword(TemplateURL* t_url) const {
-  EnsureKeyword(t_url);
-  return keyword_;
-}
-
-void TemplateURLData::SetAutogenerateKeyword(bool autogenerate_keyword) {
-  autogenerate_keyword_ = autogenerate_keyword;
-  if (autogenerate_keyword_) {
-    keyword_.clear();
-    keyword_generated_ = false;
-  }
-}
-
-void TemplateURLData::EnsureKeyword(TemplateURL* t_url) const {
-  if (autogenerate_keyword_ && !keyword_generated_) {
-    // Generate a keyword and cache it.
-    keyword_ = base::i18n::ToLower(TemplateURLService::GenerateKeyword(
-        TemplateURLService::GenerateSearchURL(t_url).GetWithEmptyPath(), true));
-    keyword_generated_ = true;
-  }
 }
 
 void TemplateURLData::SetURL(const std::string& url) {
   DCHECK(!url.empty());
   url_ = url;
 }
 
 
 // TemplateURL ----------------------------------------------------------------
 
@@ skipping 64 matching lines @@
 bool TemplateURL::SupportsReplacement() const {
   UIThreadSearchTermsData search_terms_data;
   return SupportsReplacementUsingTermsData(search_terms_data);
 }
 
 bool TemplateURL::SupportsReplacementUsingTermsData(
     const SearchTermsData& search_terms_data) const {
   return url_ref_.SupportsReplacementUsingTermsData(search_terms_data);
 }
 
+bool TemplateURL::IsGoogleSearchURLWithReplaceableKeyword() const {
+  return !IsExtensionKeyword() && url_ref_.HasGoogleBaseURLs() &&
+      google_util::IsGoogleHostname(UTF16ToUTF8(data_.keyword()),
+                                    google_util::DISALLOW_SUBDOMAIN);
+}
+
 std::string TemplateURL::GetExtensionId() const {
   DCHECK(IsExtensionKeyword());
   return GURL(data_.url()).host();
 }
 
 bool TemplateURL::IsExtensionKeyword() const {
   return GURL(data_.url()).SchemeIs(chrome::kExtensionScheme);
 }
 
 void TemplateURL::SetURL(const std::string& url) {
   data_.SetURL(url);
   url_ref_.InvalidateCachedValues();
 }
 
 void TemplateURL::SetPrepopulateId(int id) {
   data_.prepopulate_id = id;
   const bool prepopulated = id > 0;
   url_ref_.prepopulated_ = prepopulated;
   suggestions_url_ref_.prepopulated_ = prepopulated;
   instant_url_ref_.prepopulated_ = prepopulated;
 }
 
+void TemplateURL::ResetKeywordIfNecessary(bool force) {
+  if (IsGoogleSearchURLWithReplaceableKeyword() || force) {
+    DCHECK(!IsExtensionKeyword());
+    GURL url(TemplateURLService::GenerateSearchURL(this));
+    if (url.is_valid())
+      data_.SetKeyword(TemplateURLService::GenerateKeyword(url));
+  }
+}
+
 void TemplateURL::InvalidateCachedValues() {
   url_ref_.InvalidateCachedValues();
   suggestions_url_ref_.InvalidateCachedValues();
   instant_url_ref_.InvalidateCachedValues();
-  data_.SetAutogenerateKeyword(data_.autogenerate_keyword());
+  ResetKeywordIfNecessary(false);
 }