Run pre-classification checks in the browser before starting client-side phishing 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
@@ skipping 13 matching lines @@
 #include "base/callback.h"
 #include "base/file_path.h"
 #include "base/gtest_prod_util.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 "chrome/browser/safe_browsing/csd.pb.h"
 #include "chrome/common/net/url_fetcher.h"
+#include "chrome/common/notification_observer.h"
+#include "chrome/common/notification_registrar.h"
 #include "googleurl/src/gurl.h"
 
 class URLRequestContextGetter;
 
 namespace net {
 class URLRequestStatus;
 }  // namespace net
 
 namespace safe_browsing {
 
-class ClientSideDetectionService : public URLFetcher::Delegate {
+class ClientSideDetectionService : public URLFetcher::Delegate,
+                                   public NotificationObserver {
  public:
   typedef Callback1<base::PlatformFile>::Type OpenModelDoneCallback;
 
   typedef Callback2<GURL /* phishing URL */, bool /* is phishing */>::Type
       ClientReportPhishingRequestCallback;
 
   virtual ~ClientSideDetectionService();
 
   // Creates a client-side detection service and starts fetching the client-side
   // detection model if necessary.  The model will be stored in |model_path|.
   // The caller takes ownership of the object.  This function may return NULL.
   static ClientSideDetectionService* Create(
       const FilePath& model_path,
       URLRequestContextGetter* request_context_getter);
 
   // From the URLFetcher::Delegate interface.
   virtual void OnURLFetchComplete(const URLFetcher* source,
                                   const GURL& url,
                                   const net::URLRequestStatus& status,
                                   int response_code,
                                   const ResponseCookies& cookies,
                                   const std::string& data);
 
+  // From the NotificationObserver interface.
+  virtual void Observe(NotificationType type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details);
+
   // Gets the model file descriptor once the model is ready and stored
   // on disk.  If there was an error the callback is called and the
   // platform file is set to kInvalidPlatformFileValue. The
   // ClientSideDetectionService takes ownership of the |callback|.
   // The callback is always called after GetModelFile() returns and on the
   // same thread as GetModelFile() was called.
   void GetModelFile(OpenModelDoneCallback* callback);
 
   // Sends a request to the SafeBrowsing servers with the potentially phishing
   // URL and the client-side phishing score.  The |phishing_url| scheme should
   // be HTTP.  This method takes ownership of the |callback| and calls it once
   // the result has come back from the server or if an error occurs during the
   // fetch.  If an error occurs the phishing verdict will always be false.  The
   // callback is always called after SendClientReportPhishingRequest() returns
   // and on the same thread as SendClientReportPhishingRequest() was called.
   void SendClientReportPhishingRequest(
       const GURL& phishing_url,
       double score,
       ClientReportPhishingRequestCallback* callback);
 
  private:
   friend class ClientSideDetectionServiceTest;
+  class ShouldClassifyUrlRequest;
 
   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,
   };
 
@@ skipping 80 matching lines @@
 
   // 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_;
 
+  // Used to register for page load notifications.
+  NotificationRegistrar registrar_;
+
   DISALLOW_COPY_AND_ASSIGN(ClientSideDetectionService);
 };
 
 }  // namepsace safe_browsing
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_CLIENT_SIDE_DETECTION_SERVICE_H_