Added histogram on successful check. Safe verification

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/metrics/histogram.h"
+#include "base/metrics/stats_counters.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/histograms.h"
 #include "chrome/browser/protector/protector.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "googleurl/src/gurl.h"
 #include "sql/statement.h"
@@ skipping 53 matching lines @@
 }
 
 // Signs search provider id and returns its signature.
 std::string GetSearchProviderIDSignature(int64 id) {
   return protector::SignSetting(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);
+  return protector::IsSettingValid(base::Int64ToString(id), signature);
 }
 
 }  // anonymous namespace
 
 KeywordTable::~KeywordTable() {}
 
 bool KeywordTable::Init() {
   if (!db_->DoesTableExist("keywords")) {
     if (!db_->Execute("CREATE TABLE keywords ("
                       "id INTEGER PRIMARY KEY,"
@@ skipping 181 matching lines @@
   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)) {
     UMA_HISTOGRAM_ENUMERATION(
         protector::kProtectorHistogramDefaultSearchProvider,
         protector::kProtectorErrorBackupInvalid,
         protector::kProtectorErrorCount);
+    SIMPLE_STATS_COUNTER(protector::kProtectorBackupInvalidCounter);
     return true;
   } else if (backup_value != GetDefaultSearchProviderID()) {
     UMA_HISTOGRAM_ENUMERATION(
         protector::kProtectorHistogramDefaultSearchProvider,
         protector::kProtectorErrorValueChanged,
         protector::kProtectorErrorCount);
+    SIMPLE_STATS_COUNTER(protector::kProtectorValueChangedCounter);
     return true;
   }
+  UMA_HISTOGRAM_ENUMERATION(
+      protector::kProtectorHistogramDefaultSearchProvider,
+      protector::kProtectorErrorValueValid,
+      protector::kProtectorErrorCount);
+  SIMPLE_STATS_COUNTER(protector::kProtectorValueValidCounter);
   return false;
 }
 
 bool KeywordTable::SetBuiltinKeywordVersion(int version) {
   return meta_table_->SetValue(kBuiltinKeywordVersion, version);
 }
 
 int KeywordTable::GetBuiltinKeywordVersion() {
   int version = 0;
   if (!meta_table_->GetValue(kBuiltinKeywordVersion, &version))
@@ skipping 88 matching lines @@
   return
       meta_table_->SetValue(kDefaultSearchProviderBackupKey, id) &&
       SetDefaultSearchProviderBackupIDSignature(id);
 }
 
 bool KeywordTable::SetDefaultSearchProviderBackupIDSignature(int64 id) {
   return meta_table_->SetValue(
       kDefaultSearchProviderBackupSignatureKey,
       GetSearchProviderIDSignature(id));
 }