Added Protector, hooked up DSE verification with error bubble.

chrome/browser/webdata/keyword_table.cc

 // Copyright (c) 2011 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 "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/history/history_database.h"
+#include "chrome/browser/protector/protector.h"
+#include "chrome/browser/protector/keys.h"
 #include "chrome/browser/search_engines/template_url.h"
-#include "crypto/hmac.h"
 #include "googleurl/src/gurl.h"
 #include "sql/statement.h"
 
 using base::Time;
 
 namespace {
 
 // ID of the url column in keywords.
 const int kUrlIdPosition = 18;
 
 // Keys used in the meta table.
 const char kDefaultSearchProviderKey[] = "Default Search Provider ID";
 const char kBuiltinKeywordVersion[] = "Builtin Keyword Version";
 
-// Key for signing the default search provider backup.
-// TOOD(avayvod): Add key for Google Chrome to internal repository.
-const char kDefaultSearchProviderBackupSigningKey[] =
-    "Please, don't change default search engine!";
-
 // Meta table key to store backup value for the default search provider.
 const char kDefaultSearchProviderBackupKey[] =
     "Default Search Provider ID Backup";
 
 // Meta table key to store backup value signature for the default search
 // provider.
 const char kDefaultSearchProviderBackupSignatureKey[] =
     "Default Search Provider ID Backup Signature";
 
 void BindURLToStatement(const TemplateURL& url, sql::Statement* s) {
@@ skipping 25 matching lines @@
   s->BindInt(13, url.logo_id());
   s->BindBool(14, url.created_by_policy());
   s->BindString(15, url.instant_url() ? url.instant_url()->url() :
                 std::string());
   s->BindInt64(16, url.last_modified().ToTimeT());
   s->BindString(17, url.sync_guid());
 }
 
 // Signs search provider id and returns its signature.
 std::string GetSearchProviderIDSignature(int64 id) {
-  crypto::HMAC hmac(crypto::HMAC::SHA256);
-  DCHECK(hmac.Init(kDefaultSearchProviderBackupSigningKey));
-
-  std::string id_to_sign(base::Int64ToString(id));
-  std::vector<unsigned char> digest(hmac.DigestLength());
-  DCHECK(hmac.Sign(id_to_sign, &digest[0], digest.size()));
-
-  return std::string(&digest[0], &digest[0] + digest.size());
+  return protector::Sign(base::Int64ToString(id));
 }
 
 // Checks if signature for search provider id is correct and returns the
 // result.
 bool IsSearchProviderIDValid(int64 id, const std::string& signature) {
   return signature == GetSearchProviderIDSignature(id);
 }
 
 }  // anonymous namespace
 
@@ skipping 154 matching lines @@
       "sync_guid=? WHERE id=?"));
   if (!s) {
     NOTREACHED() << "Statement prepare failed";
     return false;
   }
   BindURLToStatement(url, &s);
   s.BindInt64(kUrlIdPosition, url.id());
   return s.Run();
 }
 
+string16 KeywordTable::GetKeywordShortName(int64 id) {
+  sql::Statement s(db_->GetUniqueStatement(
+      "SELECT short_name FROM keywords WHERE id=?"));
+  if (!s) {
+    NOTREACHED() << "Statement prepare failed";
+    return string16();
+  }
+  s.BindInt64(0, id);
+  if (s.Step()) {
+    std::string short_name(s.ColumnString(0));
+    DCHECK(!short_name.empty());
+    return UTF8ToUTF16(short_name);
+  }
+  LOG(WARNING) << "Keyword with id " << id << " is not found.";
+  return string16();
+}
+
 bool KeywordTable::SetDefaultSearchProviderID(int64 id) {
   return meta_table_->SetValue(kDefaultSearchProviderKey, id) &&
       SetDefaultSearchProviderBackupID(id);
 }
 
 int64 KeywordTable::GetDefaultSearchProviderID() {
   int64 value = 0;
   meta_table_->GetValue(kDefaultSearchProviderKey, &value);
   int64 backup_value = 0;
   meta_table_->GetValue(kDefaultSearchProviderBackupKey, &backup_value);
   std::string backup_signature;
   meta_table_->GetValue(
       kDefaultSearchProviderBackupSignatureKey, &backup_signature);
   if (!IsSearchProviderIDValid(backup_value, backup_signature)) {
-    // TODO(avayvod): Notify UI about the setting having been hijacked and
-    // the backup value lost.
-    return value;
+    scoped_refptr<protector::DefaultSearchProviderChange> change(

[sky, 2011/10/19 21:09:12]

I don't like putting functionality like this in the DB or running it on this
thread. The DB should be a stateless as possible. Instead have this state
checked from WebDataServices call to Init and pass that back to the UI thread
for processing.

[whywhat, 2011/10/20 23:02:39]

Done.

+        new protector::DefaultSearchProviderChange(this, 0, value));
+    protector::NotifyUserOfChange(change);
+    SetDefaultSearchProviderID(0);
+    return 0;
   }
   if (value != backup_value) {
-    // TODO(avayvod): Notify UI about the setting having been hijacked.
+    scoped_refptr<protector::DefaultSearchProviderChange> change(
+        new protector::DefaultSearchProviderChange(this, backup_value, value));
+    protector::NotifyUserOfChange(change);
+    SetDefaultSearchProviderID(backup_value);
     return backup_value;
   }
   return value;
 }
 
 bool KeywordTable::SetBuiltinKeywordVersion(int version) {
   return meta_table_->SetValue(kBuiltinKeywordVersion, version);
 }
 
 int KeywordTable::GetBuiltinKeywordVersion() {
@@ skipping 90 matching lines @@
   return
       meta_table_->SetValue(kDefaultSearchProviderBackupKey, id) &&
       SetDefaultSearchProviderBackupIDSignature(id);
 }
 
 bool KeywordTable::SetDefaultSearchProviderBackupIDSignature(int64 id) {
   return meta_table_->SetValue(
       kDefaultSearchProviderBackupSignatureKey,
       GetSearchProviderIDSignature(id));
 }