chrome/browser/renderer_host/safe_browsing_resource_throttle.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_BROWSER_RENDERER_HOST_SAFE_BROWSING_RESOURCE_THROTTLE_H_
   6 #define CHROME_BROWSER_RENDERER_HOST_SAFE_BROWSING_RESOURCE_THROTTLE_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/memory/ref_counted.h"
  12 #include "base/time.h"
  13 #include "base/timer.h"
  14 #include "chrome/browser/safe_browsing/database_manager.h"
  15 #include "chrome/browser/safe_browsing/ui_manager.h"
  16 #include "content/public/browser/resource_throttle.h"
  17
  18 class ResourceDispatcherHost;
  19
  20 namespace net {
  21 class URLRequest;
  22 }
  23
  24 // SafeBrowsingResourceThrottle checks that URLs are "safe" before navigating
  25 // to them. To be considered "safe", a URL must not appear in the
  26 // malware/phishing blacklists (see SafeBrowsingService for details).
  27 //
  28 // This check is done before requesting the original URL, and additionally
  29 // before following any subsequent redirect.
  30 //
  31 // In the common case, the check completes synchronously (no match in the bloom
  32 // filter), so the request's flow is un-interrupted.
  33 //
  34 // However if the URL fails this quick check, it has the possibility of being
  35 // on the blacklist. Now the request is suspended (prevented from starting),
  36 // and a more expensive safe browsing check is begun (fetches the full hashes).
  37 //
  38 // Note that the safe browsing check takes at most kCheckUrlTimeoutMs
  39 // milliseconds. If it takes longer than this, then the system defaults to
  40 // treating the URL as safe.
  41 //
  42 // Once the safe browsing check has completed, if the URL was decided to be
  43 // dangerous, a warning page is thrown up and the request remains suspended.
  44 // If on the other hand the URL was decided to be safe, the request is
  45 // resumed.
  46 class SafeBrowsingResourceThrottle
  47     : public content::ResourceThrottle,
  48       public SafeBrowsingDatabaseManager::Client,
  49       public base::SupportsWeakPtr<SafeBrowsingResourceThrottle> {
  50  public:
  51   SafeBrowsingResourceThrottle(const net::URLRequest* request,
  52                                int render_process_host_id,
  53                                int render_view_id,
  54                                bool is_subresource,
  55                                SafeBrowsingService* safe_browsing);
  56
  57   // content::ResourceThrottle implementation (called on IO thread):
  58   virtual void WillStartRequest(bool* defer) OVERRIDE;
  59   virtual void WillRedirectRequest(const GURL& new_url, bool* defer) OVERRIDE;
  60
  61   // SafeBrowsingDabaseManager::Client implementation (called on IO thread):
  62   virtual void OnCheckBrowseUrlResult(
  63       const GURL& url, SBThreatType result) OVERRIDE;
  64
  65  private:
  66   // Describes what phase of the check a throttle is in.
  67   enum State {
  68     STATE_NONE,
  69     STATE_CHECKING_URL,
  70     STATE_DISPLAYING_BLOCKING_PAGE,
  71   };
  72
  73   // Describes what stage of the request got paused by the check.
  74   enum DeferState {
  75     DEFERRED_NONE,
  76     DEFERRED_START,
  77     DEFERRED_REDIRECT,
  78   };
  79
  80   virtual ~SafeBrowsingResourceThrottle();
  81
  82   // SafeBrowsingService::UrlCheckCallback implementation.
  83   void OnBlockingPageComplete(bool proceed);
  84
  85   // Starts running |url| through the safe browsing check. Returns true if the
  86   // URL is safe to visit. Otherwise returns false and will call
  87   // OnBrowseUrlResult() when the check has completed.
  88   bool CheckUrl(const GURL& url);
  89
  90   // Callback for when the safe browsing check (which was initiated by
  91   // StartCheckingUrl()) has taken longer than kCheckUrlTimeoutMs.
  92   void OnCheckUrlTimeout();
  93
  94   // Starts displaying the safe browsing interstitial page.
  95   void StartDisplayingBlockingPage(const GURL& url, SBThreatType threat_type);
  96
  97   // Resumes the request, by continuing the deferred action (either starting the
  98   // request, or following a redirect).
  99   void ResumeRequest();
 100
 101   State state_;
 102   DeferState defer_state_;
 103
 104   // The result of the most recent safe browsing check. Only valid to read this
 105   // when state_ != STATE_CHECKING_URL.
 106   SBThreatType threat_type_;
 107
 108   // The time when the outstanding safe browsing check was started.
 109   base::TimeTicks url_check_start_time_;
 110
 111   // Timer to abort the safe browsing check if it takes too long.
 112   base::OneShotTimer<SafeBrowsingResourceThrottle> timer_;
 113
 114   // The redirect chain for this resource
 115   std::vector<GURL> redirect_urls_;
 116
 117   GURL url_being_checked_;
 118
 119   int render_process_host_id_;
 120   int render_view_id_;
 121   scoped_refptr<SafeBrowsingDatabaseManager> database_manager_;
 122   scoped_refptr<SafeBrowsingUIManager> ui_manager_;
 123   const net::URLRequest* request_;
 124   bool is_subresource_;
 125
 126   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingResourceThrottle);
 127 };
 128
 129
 130 #endif  // CHROME_BROWSER_RENDERER_HOST_SAFE_BROWSING_RESOURCE_THROTTLE_H_