Optimize phishing page term feature extraction.

chrome/renderer/safe_browsing/phishing_term_feature_extractor.h

 // 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.
 //
 // PhishingTermFeatureExtractor handles computing term features from the text
 // of a web page for the client-side phishing detection model.  To do this, it
 // takes a list of terms that appear in the model, and scans through the page
 // text looking for them.  Any terms that appear will cause a corresponding
 // features::kPageTerm feature to be added to the FeatureMap.
 //
 // To make it harder for a phisher to enumerate all of the relevant terms in
 // the model, the terms are provided as SHA-256 hashes, rather than plain text.
 //
 // There is one PhishingTermFeatureExtractor per RenderView.
 
 #ifndef CHROME_RENDERER_SAFE_BROWSING_PHISHING_TERM_FEATURE_EXTRACTOR_H_
 #define CHROME_RENDERER_SAFE_BROWSING_PHISHING_TERM_FEATURE_EXTRACTOR_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/callback_old.h"
 #include "base/hash_tables.h"
+#include "base/memory/mru_cache.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/string_piece.h"
 #include "base/string16.h"
 #include "base/task.h"
 
 namespace safe_browsing {
 class FeatureExtractorClock;
 class FeatureMap;
 
 class PhishingTermFeatureExtractor {
  public:
   // Callback to be run when feature extraction finishes.  The callback
@@ skipping 50 matching lines @@
 
   // The number of words that we will process before checking to see whether
   // kMaxTimePerChunkMs has elapsed.  Since checking the current time can be
   // slow, we don't do this on every word processed.
   static const int kClockCheckGranularity;
 
   // The maximum total amount of time that the feature extractor will run
   // before giving up on the current page.
   static const int kMaxTotalTimeMs;
 
+  // The size of the cache that we use to determine if we can avoid lower
+  // casing, hashing, and UTF conversion.
+  static const int kMaxNegativeWordCacheSize;
+
   // Does the actual work of ExtractFeatures.  ExtractFeaturesWithTimeout runs
   // until a predefined maximum amount of time has elapsed, then posts a task
   // to the current MessageLoop to continue extraction.  When extraction
   // finishes, calls RunCallback().
   void ExtractFeaturesWithTimeout();
 
   // Handles a single word in the page text.
-  void HandleWord(const string16& word);
+  void HandleWord(const base::StringPiece16& word);
 
   // Helper to verify that there is no pending feature extraction.  Dies in
   // debug builds if the state is not as expected.  This is a no-op in release
   // builds.
   void CheckNoPendingExtraction();
 
   // Runs |done_callback_| and then clears all internal state.
   void RunCallback(bool success);
 
   // Clears all internal feature extraction state.
   void Clear();
 
   // All of the term hashes that we are looking for in the page.
   const base::hash_set<std::string>* page_term_hashes_;
 
   // Hashes of all the individual words in page_term_hashes_.  If
   // page_term_hashes_ included (hashed) "one" and "one two", page_word_hashes_
   // would contain (hashed) "one" and "two".  We do this so that we can have a
   // quick out in the common case that the current word we are processing
   // doesn't contain any part of one of our terms.
   const base::hash_set<std::string>* page_word_hashes_;
 
   // The maximum number of words in an n-gram.
   size_t max_words_per_term_;
 
+  // This cache is used to see if we need to check the word at all, as
+  // converting to UTF8, lowercasing, and hashing are all relatively expensive
+  // operations. Though this is called an MRU cache, it seems to behave like
+  // an LRU cache (i.e. it evicts the oldest accesses first).
+  typedef base::HashingMRUCache<base::StringPiece16, bool> WordCache;
+  WordCache negative_word_cache_;
+
   // Non-owned pointer to our clock.
   FeatureExtractorClock* clock_;
 
   // The output parameters from the most recent call to ExtractFeatures().
   const string16* page_text_;  // The caller keeps ownership of this.
   FeatureMap* features_;  // The caller keeps ownership of this.
   scoped_ptr<DoneCallback> done_callback_;
 
   // Stores the current state of term extraction from |page_text_|.
   scoped_ptr<ExtractionState> state_;
 
   // Used to create ExtractFeaturesWithTimeout tasks.
   // These tasks are revoked if extraction is cancelled.
   ScopedRunnableMethodFactory<PhishingTermFeatureExtractor> method_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(PhishingTermFeatureExtractor);
 };
 
 }  // namespace safe_browsing
 
 #endif  // CHROME_RENDERER_SAFE_BROWSING_PHISHING_TERM_FEATURE_EXTRACTOR_H_