Add search_terms_replacement_key field to TemplateURL.

chrome/browser/webdata/keyword_table.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/webdata/keyword_table.h"
 
 #include <set>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
@@ skipping 55 matching lines @@
     columns.push_back("logo_id");
   }
   columns.push_back("created_by_policy");
   columns.push_back("instant_url");
   columns.push_back("last_modified");
   columns.push_back("sync_guid");
   if (version >= 47) {
     // Column added in version 47.
     columns.push_back("alternate_urls");
   }
+  if (version >= 48) {
+    // Column added in version 48.
+    columns.push_back("search_terms_replacement_key");
+  }
 
   return JoinString(columns, std::string(concatenated ? " || " : ", "));
 }
 
 
 // Inserts the data from |data| into |s|.  |s| is assumed to have slots for all
 // the columns in the keyword table.  |id_column| is the slot number to bind
 // |data|'s |id| to; |starting_column| is the slot number of the first of a
 // contiguous set of slots to bind all the other fields to.
 void BindURLToStatement(const TemplateURLData& data,
@@ skipping 25 matching lines @@
   s->BindInt(starting_column + 7, data.usage_count);
   s->BindString(starting_column + 8, JoinString(data.input_encodings, ';'));
   s->BindBool(starting_column + 9, data.show_in_default_list);
   s->BindString(starting_column + 10, data.suggestions_url);
   s->BindInt(starting_column + 11, data.prepopulate_id);
   s->BindBool(starting_column + 12, data.created_by_policy);
   s->BindString(starting_column + 13, data.instant_url);
   s->BindInt64(starting_column + 14, data.last_modified.ToTimeT());
   s->BindString(starting_column + 15, data.sync_guid);
   s->BindString(starting_column + 16, alternate_urls);
+  s->BindString(starting_column + 17, data.search_terms_replacement_key);
 }
 
 }  // anonymous namespace
 
 KeywordTable::KeywordTable(sql::Connection* db, sql::MetaTable* meta_table)
     : WebDatabaseTable(db, meta_table),
       backup_overwritten_(false) {
 }
 
 KeywordTable::~KeywordTable() {}
@@ skipping 11 matching lines @@
                     "date_created INTEGER DEFAULT 0,"
                     "usage_count INTEGER DEFAULT 0,"
                     "input_encodings VARCHAR,"
                     "show_in_default_list INTEGER,"
                     "suggest_url VARCHAR,"
                     "prepopulate_id INTEGER DEFAULT 0,"
                     "created_by_policy INTEGER DEFAULT 0,"
                     "instant_url VARCHAR,"
                     "last_modified INTEGER DEFAULT 0,"
                     "sync_guid VARCHAR,"
-                    "alternate_urls VARCHAR)") &&
+                    "alternate_urls VARCHAR,"
+                    "search_terms_replacement_key VARCHAR)") &&
        UpdateBackupSignature(WebDatabase::kCurrentVersionNumber));
 }
 
 bool KeywordTable::IsSyncable() {
   return true;
 }
 
 bool KeywordTable::AddKeyword(const TemplateURLData& data) {
   DCHECK(data.id);
   std::string query("INSERT INTO keywords (" + GetKeywordColumns() +
-                    ") VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)");
+                    ") VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)");
   sql::Statement s(db_->GetUniqueStatement(query.c_str()));
   BindURLToStatement(data, &s, 0, 1);
 
   return s.Run() && UpdateBackupSignature(WebDatabase::kCurrentVersionNumber);
 }
 
 bool KeywordTable::RemoveKeyword(TemplateURLID id) {
   DCHECK(id);
   sql::Statement s(
       db_->GetUniqueStatement("DELETE FROM keywords WHERE id = ?"));
@@ skipping 22 matching lines @@
   return succeeded;
 }
 
 bool KeywordTable::UpdateKeyword(const TemplateURLData& data) {
   DCHECK(data.id);
   sql::Statement s(db_->GetUniqueStatement("UPDATE keywords SET short_name=?, "
       "keyword=?, favicon_url=?, url=?, safe_for_autoreplace=?, "
       "originating_url=?, date_created=?, usage_count=?, input_encodings=?, "
       "show_in_default_list=?, suggest_url=?, prepopulate_id=?, "
       "created_by_policy=?, instant_url=?, last_modified=?, sync_guid=?, "
-      "alternate_urls=? WHERE id=?"));
-  BindURLToStatement(data, &s, 17, 0);  // "17" binds id() as the last item.
+      "alternate_urls=?, search_terms_replacement_key=? WHERE id=?"));
+  BindURLToStatement(data, &s, 18, 0);  // "18" binds id() as the last item.
 
   return s.Run() && UpdateBackupSignature(WebDatabase::kCurrentVersionNumber);
 }
 
 bool KeywordTable::SetDefaultSearchProviderID(int64 id) {
   // Added for http://crbug.com/116952.
   UMA_HISTOGRAM_COUNTS_100("Search.DefaultSearchProviderID",
                            static_cast<int32>(id));
   return meta_table_->SetValue(kDefaultSearchProviderKey, id) &&
       UpdateBackupSignature(WebDatabase::kCurrentVersionNumber);
@@ skipping 214 matching lines @@
     // Old backup was invalid; drop the table entirely, which will trigger the
     // protector code to prompt the user and recreate the table.
     if (db_->DoesTableExist("keywords_backup") &&
         !db_->Execute("DROP TABLE keywords_backup"))
       return false;
   }
 
   return transaction.Commit();
 }
 
+bool KeywordTable::MigrateToVersion48AddSearchTermsReplacementKeyColumn() {
+  sql::Transaction transaction(db_);
+
+  // Fill the |search_terms_replacement_key| column with empty strings,
+  // otherwise it breaks code relying on GetTableContents that concatenates the
+  // strings from all the columns.
+  if (!transaction.Begin() ||
+      !db_->Execute("ALTER TABLE keywords ADD COLUMN "
+                    "search_terms_replacement_key VARCHAR DEFAULT ''"))
+    return false;
+
+  if (IsBackupSignatureValid(47)) {
+    // Migrate the keywords backup table as well.
+    if (!db_->Execute("ALTER TABLE keywords_backup ADD COLUMN "
+                      "search_terms_replacement_key VARCHAR DEFAULT ''") ||
+        !SignBackup(48))
+      return false;
+  } else {
+    // Old backup was invalid; drop the table entirely, which will trigger the
+    // protector code to prompt the user and recreate the table.
+    if (db_->DoesTableExist("keywords_backup") &&
+        !db_->Execute("DROP TABLE keywords_backup"))
+      return false;
+  }
+
+  return transaction.Commit();
+}
+
 // static
 bool KeywordTable::GetKeywordDataFromStatement(const sql::Statement& s,
                                                TemplateURLData* data) {
   DCHECK(data);
 
   data->short_name = s.ColumnString16(1);
   data->SetKeyword(s.ColumnString16(2));
   // Due to past bugs, we might have persisted entries with empty URLs.  Avoid
   // reading these out.  (GetKeywords() will delete these entries on return.)
   // NOTE: This code should only be needed as long as we might be reading such
@@ skipping 21 matching lines @@
   scoped_ptr<Value> value(json_reader.ReadToValue(s.ColumnString(17)));
   ListValue* alternate_urls_value;
   if (value.get() && value->GetAsList(&alternate_urls_value)) {
     std::string alternate_url;
     for (size_t i = 0; i < alternate_urls_value->GetSize(); ++i) {
       if (alternate_urls_value->GetString(i, &alternate_url))
         data->alternate_urls.push_back(alternate_url);
     }
   }
 
+  data->search_terms_replacement_key = s.ColumnString(18);
+
   return true;
 }
 
 bool KeywordTable::GetSignatureData(int table_version, std::string* backup) {
   DCHECK(backup);
 
   int64 backup_value = kInvalidTemplateURLID;
   if (!meta_table_->GetValue(kDefaultSearchIDBackupKey, &backup_value)) {
     LOG(ERROR) << "No backup id for signing.";
     return false;
@@ skipping 191 matching lines @@
     }
   }
 
   // Replace the old table with the new one.
   sql = "DROP TABLE " + name;
   if (!db_->Execute(sql.c_str()))
     return false;
   sql = "ALTER TABLE keywords_temp RENAME TO " + name;
   return db_->Execute(sql.c_str());
 }