Add caching to phishing client side detection.

chrome/browser/safe_browsing/client_side_detection_service.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.
 //
 // Helper class which handles communication with the SafeBrowsing backends for
 // client-side phishing detection.  This class can be used to get a file
 // descriptor to the client-side phishing model and also to send a ping back to
 // Google to verify if a particular site is really phishing or not.
 //
 // This class is not thread-safe and expects all calls to GetModelFile() and
 // SendClientReportPhishingRequest() to be made on the UI thread.  We also
 // expect that the calling thread runs a message loop and that there is a FILE
 // thread running to execute asynchronous file operations.
 
 #ifndef CHROME_BROWSER_SAFE_BROWSING_CLIENT_SIDE_DETECTION_SERVICE_H_
 #define CHROME_BROWSER_SAFE_BROWSING_CLIENT_SIDE_DETECTION_SERVICE_H_
 #pragma once
 
 #include <map>
 #include <queue>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
+#include "base/linked_ptr.h"
 #include "base/platform_file.h"
 #include "base/ref_counted.h"
 #include "base/scoped_callback_factory.h"
 #include "base/scoped_ptr.h"
 #include "base/task.h"
 #include "base/time.h"
 #include "chrome/browser/safe_browsing/csd.pb.h"
 #include "chrome/common/net/url_fetcher.h"
 #include "googleurl/src/gurl.h"
 
@@ skipping 54 matching lines @@
 
   enum ModelStatus {
     // It's unclear whether or not the model was already fetched.
     UNKNOWN_STATUS,
     // Model is fetched and is stored on disk.
     READY_STATUS,
     // Error occured during fetching or writing.
     ERROR_STATUS,
   };
 
+  // CacheState holds all information necessary to respond to a caller without
+  // actually making a HTTP request.
+  struct CacheState {
+    bool is_phishing;
+    base::Time timestamp;
+
+    CacheState(bool phish, base::Time time);
+  };
+  typedef std::map<GURL, linked_ptr<CacheState> > PhishingCache;
+
   static const char kClientReportPhishingUrl[];
   static const char kClientModelUrl[];
-  static const int kMaxReportsPerDay;
+  static const int kMaxReportsPerInterval;
+  static const base::TimeDelta kReportsInterval;
+  static const base::TimeDelta kNegativeCacheInterval;
+  static const base::TimeDelta kPositiveCacheInterval;
 
   // Use Create() method to create an instance of this object.
   ClientSideDetectionService(const FilePath& model_path,
                              URLRequestContextGetter* request_context_getter);
 
   // Sets the model status and invokes all the pending callbacks in
   // |open_callbacks_| with the current |model_file_| as parameter.
   void SetModelStatus(ModelStatus status);
 
   // Called once the initial open() of the model file is done.  If the file
@@ skipping 43 matching lines @@
 
   // Called by OnURLFetchComplete to handle the server response from
   // sending the client-side phishing request.
   void HandlePhishingVerdict(const URLFetcher* source,
                              const GURL& url,
                              const net::URLRequestStatus& status,
                              int response_code,
                              const ResponseCookies& cookies,
                              const std::string& data);
 
-  // Get the number of phishing reports that we have sent over the last 24
-  // hours.
-  int GetNumReportsPerDay();
+  // Returns true and sets is_phishing if url is in the cache and valid.
+  bool GetCachedResult(const GURL& url, bool* is_phishing);
+
+  // Invalidate cache results which are no longer useful.
+  void UpdateCache();
+
+  // Get the number of phishing reports that we have sent over kReportsInterval
+  int GetNumReports();
 
   FilePath model_path_;
   ModelStatus model_status_;
   base::PlatformFile model_file_;
   scoped_ptr<URLFetcher> model_fetcher_;
   scoped_ptr<std::string> tmp_model_string_;
   std::vector<OpenModelDoneCallback*> open_callbacks_;
 
   // Map of client report phishing request to the corresponding callback that
   // has to be invoked when the request is done.
   struct ClientReportInfo;
   std::map<const URLFetcher*, ClientReportInfo*> client_phishing_reports_;
 
+  // Cache of completed requests. Used to satisfy requests for the same urls
+  // as long as the next request falls within our caching window (which is
+  // determined by kNegativeCacheInterval and kPositiveCacheInterval). The
+  // size of this cache is limited by kMaxReportsPerDay *
+  // ceil(InDays(max(kNegativeCacheInterval, kPositiveCacheInterval))).
+  // TODO(gcasto): Serialize this so that it doesn't reset on browser restart.
+  PhishingCache cache_;
+
   // Timestamp of when we sent a phishing request. Used to limit the number
   // of phishing requests that we send in a day.
   // TODO(gcasto): Serialize this so that it doesn't reset on browser restart.
   std::queue<base::Time> phishing_report_times_;
 
   // Used to asynchronously call the callbacks for GetModelFile and
   // SendClientReportPhishingRequest.
   ScopedRunnableMethodFactory<ClientSideDetectionService> method_factory_;
 
   // The client-side detection service object (this) might go away before some
   // of the callbacks are done (e.g., asynchronous file operations).  The
   // callback factory will revoke all pending callbacks if this goes away to
   // avoid a crash.
   base::ScopedCallbackFactory<ClientSideDetectionService> callback_factory_;
 
   // The context we use to issue network requests.
   scoped_refptr<URLRequestContextGetter> request_context_getter_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientSideDetectionService);
 };
 
 }  // namepsace safe_browsing
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_CLIENT_SIDE_DETECTION_SERVICE_H_