src/chrome/browser/captive_portal/captive_portal_tab_reloader.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_CAPTIVE_PORTAL_CAPTIVE_PORTAL_TAB_RELOADER_H_
   6 #define CHROME_BROWSER_CAPTIVE_PORTAL_CAPTIVE_PORTAL_TAB_RELOADER_H_
   7
   8 #include "base/basictypes.h"
   9 #include "base/callback_forward.h"
  10 #include "base/compiler_specific.h"
  11 #include "base/memory/weak_ptr.h"
  12 #include "base/time/time.h"
  13 #include "base/timer/timer.h"
  14 #include "chrome/browser/captive_portal/captive_portal_service.h"
  15
  16 class Profile;
  17
  18 namespace content {
  19 class WebContents;
  20 }
  21
  22 namespace net {
  23 class SSLInfo;
  24 }
  25
  26 namespace captive_portal {
  27
  28 // Keeps track of whether a tab has encountered a navigation error caused by a
  29 // captive portal.  Also triggers captive portal checks when a page load may
  30 // have been broken or be taking longer due to a captive portal.  All methods
  31 // may only be called on the UI thread.
  32 //
  33 // Only supports SSL main frames which end at error pages as a result of
  34 // captive portals, since these make for a particularly bad user experience.
  35 // Non-SSL requests are intercepted by captive portals, which take users to the
  36 // login page.  SSL requests, however, may be silently blackholed, or result
  37 // in a variety of error pages, and will continue to do so if a user tries to
  38 // reload them.
  39 class CaptivePortalTabReloader {
  40  public:
  41   enum State {
  42     STATE_NONE,
  43     // The slow load timer is running.  Only started on SSL provisional loads.
  44     // If the timer triggers before the page has been committed, a captive
  45     // portal test will be requested.
  46     STATE_TIMER_RUNNING,
  47     // The tab may have been broken by a captive portal.  A tab switches to
  48     // this state either on a main frame SSL error that may be caused by a
  49     // captive portal, or when an SSL request takes too long to commit.  The
  50     // tab will remain in this state until the current load succeeds, a new
  51     // provisional load starts, it gets a captive portal result, or the load
  52     // fails with error that indicates the page was not broken by a captive
  53     // portal.
  54     STATE_MAYBE_BROKEN_BY_PORTAL,
  55     // The TabHelper switches to this state from STATE_MAYBE_BROKEN_BY_PORTAL in
  56     // response to a RESULT_BEHIND_CAPTIVE_PORTAL.  The tab will remain in this
  57     // state until a new provisional load starts, the original load successfully
  58     // commits, the current load is aborted, or the tab reloads the page in
  59     // response to receiving a captive portal result other than
  60     // RESULT_BEHIND_CAPTIVE_PORTAL.
  61     STATE_BROKEN_BY_PORTAL,
  62     // The page may need to be reloaded.  The tab will be reloaded if the page
  63     // fails the next load with a timeout, or immediately upon switching to this
  64     // state, if the page already timed out.  If anything else happens
  65     // when in this state (Another error, successful navigation, or the original
  66     // navigation was aborted), the TabHelper transitions to STATE_NONE without
  67     // reloading.
  68     STATE_NEEDS_RELOAD,
  69   };
  70
  71   // Function to open a login tab, if there isn't one already.
  72   typedef base::Callback<void()> OpenLoginTabCallback;
  73
  74   // |profile| and |web_contents| will only be dereferenced in ReloadTab,
  75   // MaybeOpenCaptivePortalLoginTab, and CheckForCaptivePortal, so they can
  76   // both be NULL in the unit tests as long as those functions are not called.
  77   CaptivePortalTabReloader(Profile* profile,
  78                            content::WebContents* web_contents,
  79                            const OpenLoginTabCallback& open_login_tab_callback);
  80
  81   virtual ~CaptivePortalTabReloader();
  82
  83   // The following functions are all invoked by the CaptivePortalTabHelper:
  84
  85   // Called when a non-error main frame load starts.  Resets current state,
  86   // unless this is a login tab.  Each load will eventually result in a call to
  87   // OnLoadCommitted or OnAbort.  The former will be called both on successful
  88   // loads and for error pages.
  89   virtual void OnLoadStart(bool is_ssl);
  90
  91   // Called when the main frame is committed.  |net_error| will be net::OK in
  92   // the case of a successful load.  For an errror page, the entire 3-step
  93   // process of getting the error, starting a new provisional load for the error
  94   // page, and committing the error page is treated as a single commit.
  95   //
  96   // The Link Doctor page will typically be one OnLoadCommitted with an error
  97   // code, followed by another OnLoadCommitted with net::OK for the Link Doctor
  98   // page.
  99   virtual void OnLoadCommitted(int net_error);
 100
 101   // This is called when the current provisional main frame load is canceled.
 102   // Sets state to STATE_NONE, unless this is a login tab.
 103   virtual void OnAbort();
 104
 105   // Called whenever a provisional load to the main frame is redirected.
 106   virtual void OnRedirect(bool is_ssl);
 107
 108   // Called whenever a captive portal test completes.
 109   virtual void OnCaptivePortalResults(Result previous_result, Result result);
 110
 111   // Called on certificate errors, which often indicate a captive portal.
 112   void OnSSLCertError(const net::SSLInfo& ssl_info);
 113
 114  protected:
 115   // The following functions are used only when testing:
 116
 117   State state() const { return state_; }
 118
 119   content::WebContents* web_contents() { return web_contents_; }
 120
 121   void set_slow_ssl_load_time(base::TimeDelta slow_ssl_load_time) {
 122     slow_ssl_load_time_ = slow_ssl_load_time;
 123   }
 124
 125   // Started whenever an SSL tab starts loading, when the state is switched to
 126   // STATE_TIMER_RUNNING.  Stopped on any state change, including when a page
 127   // commits or there's an error.  If the timer triggers, the state switches to
 128   // STATE_MAYBE_BROKEN_BY_PORTAL and |this| kicks off a captive portal check.
 129   base::OneShotTimer<CaptivePortalTabReloader> slow_ssl_load_timer_;
 130
 131  private:
 132   friend class CaptivePortalBrowserTest;
 133
 134   // Sets |state_| and takes any action associated with the new state.  Also
 135   // stops the timer, if needed.
 136   void SetState(State new_state);
 137
 138   // Called by a timer when an SSL main frame provisional load is taking a
 139   // while to commit.
 140   void OnSlowSSLConnect();
 141
 142   // Reloads the tab if there's no provisional load going on and the current
 143   // state is STATE_NEEDS_RELOAD.  Not safe to call synchronously when called
 144   // by from a WebContentsObserver function, since the WebContents is currently
 145   // performing some action.
 146   void ReloadTabIfNeeded();
 147
 148   // Reloads the tab.
 149   virtual void ReloadTab();
 150
 151   // Opens a login tab in the topmost browser window for the |profile_|, if the
 152   // profile has a tabbed browser window and the window doesn't already have a
 153   // login tab.  Otherwise, does nothing.
 154   virtual void MaybeOpenCaptivePortalLoginTab();
 155
 156   // Tries to get |profile_|'s CaptivePortalService and have it start a captive
 157   // portal check.
 158   virtual void CheckForCaptivePortal();
 159
 160   Profile* profile_;
 161   content::WebContents* web_contents_;
 162
 163   State state_;
 164
 165   // Tracks if there's a load going on that can't safely be interrupted.  This
 166   // is true between the time when a provisional load fails and when an error
 167   // page's provisional load starts, so does not perfectly align with the
 168   // notion of a provisional load used by the WebContents.
 169   bool provisional_main_frame_load_;
 170
 171   // True if there was an SSL URL the in the redirect chain for the current
 172   // provisional main frame load.
 173   bool ssl_url_in_redirect_chain_;
 174
 175   // Time to wait after a provisional HTTPS load before triggering a captive
 176   // portal check.
 177   base::TimeDelta slow_ssl_load_time_;
 178
 179   const OpenLoginTabCallback open_login_tab_callback_;
 180
 181   base::WeakPtrFactory<CaptivePortalTabReloader> weak_factory_;
 182
 183   DISALLOW_COPY_AND_ASSIGN(CaptivePortalTabReloader);
 184 };
 185
 186 }  // namespace captive_portal
 187
 188 #endif  // CHROME_BROWSER_CAPTIVE_PORTAL_CAPTIVE_PORTAL_TAB_RELOADER_H_