Switch to the new client-side phishing model that uses Murmurhash for word hashes.

chrome/renderer/safe_browsing/scorer.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/renderer/safe_browsing/scorer.h"
 
 #include <math.h>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 52 matching lines @@
     DLOG(ERROR) << "Unable to parse phishing model.  The model is missing "
                 << "some required fields.  Maybe the .proto file changed?";
     RecordScorerCreationStatus(SCORER_FAIL_MODEL_MISSING_FIELDS);
     return NULL;
   }
   RecordScorerCreationStatus(SCORER_SUCCESS);
   for (int i = 0; i < model.page_term_size(); ++i) {
     scorer->page_terms_.insert(model.hashes(model.page_term(i)));
   }
   for (int i = 0; i < model.page_word_size(); ++i) {
-    scorer->page_words_.insert(model.hashes(model.page_word(i)));
+    scorer->page_words_.insert(model.page_word(i));
   }
   return scorer.release();
 }
 
 double Scorer::ComputeScore(const FeatureMap& features) const {
   double logodds = 0.0;
   for (int i = 0; i < model_.rule_size(); ++i) {
     logodds += ComputeRuleScore(model_.rule(i), features);
   }
   return LogOdds2Prob(logodds);
 }
 
 int Scorer::model_version() const {
   return model_.version();
 }
 
 const base::hash_set<std::string>& Scorer::page_terms() const {
   return page_terms_;
 }
 
-const base::hash_set<std::string>& Scorer::page_words() const {
+const base::hash_set<uint32>& Scorer::page_words() const {
   return page_words_;
 }
 
 size_t Scorer::max_words_per_term() const {
   return model_.max_words_per_term();
 }
 
+uint32 Scorer::murmurhash3_seed() const {
+  return model_.murmur_hash_seed();
+}
+
 double Scorer::ComputeRuleScore(const ClientSideModel::Rule& rule,
                                 const FeatureMap& features) const {
   const base::hash_map<std::string, double>& feature_map = features.features();
   double rule_score = 1.0;
   for (int i = 0; i < rule.feature_size(); ++i) {
     base::hash_map<std::string, double>::const_iterator it = feature_map.find(
         model_.hashes(rule.feature(i)));
     if (it == feature_map.end() || it->second == 0.0) {
       // If the feature of the rule does not exist in the given feature map the
       // feature weight is considered to be zero.  If the feature weight is zero
       // we leave early since we know that the rule score will be zero.
       return 0.0;
     }
     rule_score *= it->second;
   }
   return rule_score * rule.weight();
 }
 }  // namespace safe_browsing