ios/web/web_state/web_state_impl.h

   1 // Copyright 2013 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 IOS_WEB_WEB_STATE_WEB_STATE_IMPL_H_
   6 #define IOS_WEB_WEB_STATE_WEB_STATE_IMPL_H_
   7
   8 #include <map>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/memory/ref_counted.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/observer_list.h"
  15 #include "base/values.h"
  16 #include "ios/web/navigation/navigation_manager_delegate.h"
  17 #include "ios/web/navigation/navigation_manager_impl.h"
  18 #include "ios/web/net/request_tracker_impl.h"
  19 #include "ios/web/public/web_state/web_state.h"
  20 #include "url/gurl.h"
  21
  22 @protocol CRWRequestTrackerDelegate;
  23 @class CRWWebController;
  24 @protocol CRWWebViewProxy;
  25 @class NSURLRequest;
  26 @class NSURLResponse;
  27
  28 namespace net {
  29 class HttpResponseHeaders;
  30 }
  31
  32 namespace web {
  33
  34 class BrowserState;
  35 struct Credential;
  36 struct FaviconURL;
  37 struct LoadCommittedDetails;
  38 class NavigationManager;
  39 class WebInterstitialImpl;
  40 class WebStateFacadeDelegate;
  41 class WebStatePolicyDecider;
  42 class WebUIIOS;
  43
  44 // Implementation of WebState.
  45 // Generally mirrors upstream's WebContents implementation.
  46 // General notes on expected WebStateImpl ownership patterns:
  47 //  - Outside of tests, WebStateImpls are created
  48 //      (a) By @Tab, when creating a new Tab.
  49 //      (b) By @SessionWindow, when decoding a saved session.
  50 //      (c) By the Copy() method, below, used when marshalling a session
  51 //          in preparation for saving.
  52 //  - WebControllers are the eventual long-term owners of WebStateImpls.
  53 //  - SessionWindows are transient owners, passing ownership into WebControllers
  54 //    during session restore, and discarding owned copies of WebStateImpls after
  55 //    writing them out for session saves.
  56 class WebStateImpl : public WebState, public NavigationManagerDelegate {
  57  public:
  58   WebStateImpl(BrowserState* browser_state);
  59   ~WebStateImpl() override;
  60
  61   // Sets the CRWWebController that backs this object. Typically
  62   // |web_controller| will also take ownership of this object. This will also
  63   // create the WebContentsIOS facade.
  64   void SetWebController(CRWWebController* web_controller);
  65
  66   // Gets or sets the delegate used to communicate with the web contents facade.
  67   WebStateFacadeDelegate* GetFacadeDelegate() const;
  68   void SetFacadeDelegate(WebStateFacadeDelegate* facade_delegate);
  69
  70   // Returns a WebStateImpl that doesn't have a browser context, web
  71   // controller, or facade set, but which otherwise has the same state variables
  72   // as the calling object (including copies of the NavigationManager and its
  73   // attendant CRWSessionController).
  74   // TODO(marq): Revisit this function and the ownership model described above;
  75   // too this depends on and interacts directly with above-the-web-level
  76   // information.
  77   WebStateImpl* CopyForSessionWindow();
  78
  79   // Notifies the observers that a provisional navigation has started.
  80   void OnProvisionalNavigationStarted(const GURL& url);
  81
  82   // Notifies the observers that the URL hash of the current page changed.
  83   void OnUrlHashChanged();
  84
  85   // Notifies the observers that the history state of the current page changed.
  86   void OnHistoryStateChanged();
  87
  88   // Called when a script command is received.
  89   // Returns true if the command was handled.
  90   bool OnScriptCommandReceived(const std::string& command,
  91                                const base::DictionaryValue& value,
  92                                const GURL& url,
  93                                bool user_is_interacting);
  94
  95   void SetIsLoading(bool is_loading);
  96
  97   // Called when a page is loaded. Must be called only once per page.
  98   void OnPageLoaded(const GURL& url, bool load_success);
  99
 100   // Called on form submission.
 101   void OnDocumentSubmitted(const std::string& form_name, bool user_initiated);
 102
 103   // Called when form activity is registered.
 104   void OnFormActivityRegistered(const std::string& form_name,
 105                                 const std::string& field_name,
 106                                 const std::string& type,
 107                                 const std::string& value,
 108                                 int key_code,
 109                                 bool input_missing);
 110
 111   // Called when new FaviconURL candidates are received.
 112   void OnFaviconUrlUpdated(const std::vector<FaviconURL>& candidates);
 113
 114   // Called when the page requests a credential.
 115   void OnCredentialsRequested(int request_id,
 116                               const GURL& source_url,
 117                               bool suppress_ui,
 118                               const std::vector<std::string>& federations,
 119                               bool user_interaction);
 120
 121   // Called when the page sends a notification that the user signed in with
 122   // |credential|.
 123   void OnSignedIn(int request_id,
 124                   const GURL& source_url,
 125                   const web::Credential& credential);
 126
 127   // Called when the page sends a notification that the user signed in.
 128   void OnSignedIn(int request_id, const GURL& source_url);
 129
 130   // Called when the page sends a notification that the user was signed out.
 131   void OnSignedOut(int request_id, const GURL& source_url);
 132
 133   // Called when the page sends a notification that the user failed to sign in
 134   // with |credential|.
 135   void OnSignInFailed(int request_id,
 136                       const GURL& source_url,
 137                       const web::Credential& credential);
 138
 139   // Called when the page sends a notification that the user failed to sign in.
 140   void OnSignInFailed(int request_id, const GURL& source_url);
 141
 142   // Returns the NavigationManager for this WebState.
 143   const NavigationManagerImpl& GetNavigationManagerImpl() const;
 144   NavigationManagerImpl& GetNavigationManagerImpl();
 145
 146   // Creates a WebUI page for the given url, owned by this object.
 147   void CreateWebUI(const GURL& url);
 148   // Clears any current WebUI. Should be called when the page changes.
 149   // TODO(stuartmorgan): Remove once more logic is moved from WebController
 150   // into this class.
 151   void ClearWebUI();
 152   // Returns true if there is a WebUI active.
 153   bool HasWebUI();
 154   // Processes a message from a WebUI displayed at the given URL.
 155   void ProcessWebUIMessage(const GURL& source_url,
 156                            const std::string& message,
 157                            const base::ListValue& args);
 158   // Invokes page load for WebUI URL with HTML. URL must have an application
 159   // specific scheme.
 160   virtual void LoadWebUIHtml(const base::string16& html, const GURL& url);
 161
 162   // Gets the HTTP response headers associated with the current page.
 163   // NOTE: For a WKWebView-based WebState, these headers are generated via
 164   // net::CreateHeadersFromNSHTTPURLResponse(); see comments in
 165   // http_response_headers_util.h for limitations.
 166   net::HttpResponseHeaders* GetHttpResponseHeaders() const;
 167
 168   // Called when HTTP response headers are received.
 169   // |resource_url| is the URL associated with the headers.
 170   // This function has no visible effects until UpdateHttpResponseHeaders() is
 171   // called.
 172   void OnHttpResponseHeadersReceived(net::HttpResponseHeaders* response_headers,
 173                                      const GURL& resource_url);
 174
 175   // Executes a JavaScript string on the page asynchronously.
 176   // TODO(shreyasv): Rename this to ExecuteJavaScript for consitency with
 177   // upstream API.
 178   virtual void ExecuteJavaScriptAsync(const base::string16& script);
 179
 180   // Returns whether the navigation corresponding to |request| should be allowed
 181   // to continue by asking its policy deciders. Defaults to true.
 182   bool ShouldAllowRequest(NSURLRequest* request);
 183   // Returns whether the navigation corresponding to |response| should be
 184   // allowed to continue by asking its policy deciders. Defaults to true.
 185   bool ShouldAllowResponse(NSURLResponse* response);
 186
 187   // Request tracker management. For now, this exposes the RequestTracker for
 188   // embedders to use.
 189   // TODO(stuartmorgan): RequestTracker should become an internal detail of this
 190   // class.
 191
 192   // Create a new tracker using |delegate| as its delegate.
 193   void InitializeRequestTracker(id<CRWRequestTrackerDelegate> delegate);
 194
 195   // Close the request tracker and delete it.
 196   void CloseRequestTracker();
 197
 198   // Returns the tracker for this WebStateImpl.
 199   RequestTrackerImpl* GetRequestTracker();
 200
 201   // Gets and sets the mode controlling the HTTP cache behavior.
 202   // TODO(rohitrao): As with the other RequestTracker-related methods, this
 203   // should become an internal detail of this class.
 204   net::RequestTracker::CacheMode GetCacheMode();
 205   void SetCacheMode(net::RequestTracker::CacheMode mode);
 206
 207   // Lazily creates (if necessary) and returns |request_group_id_|.
 208   // IMPORTANT: This should not be used for anything other than associating this
 209   // instance to network requests.
 210   // This function is only intended to be used in web/.
 211   // TODO(stuartmorgan): Move this method in an implementation file in web/.
 212   NSString* GetRequestGroupID();
 213
 214   // WebState:
 215   UIView* GetView() override;
 216   web::WebViewType GetWebViewType() const override;
 217   BrowserState* GetBrowserState() const override;
 218   void OpenURL(const WebState::OpenURLParams& params) override;
 219   NavigationManager* GetNavigationManager() override;
 220   CRWJSInjectionReceiver* GetJSInjectionReceiver() const override;
 221   const std::string& GetContentLanguageHeader() const override;
 222   const std::string& GetContentsMimeType() const override;
 223   bool ContentIsHTML() const override;
 224   const base::string16& GetTitle() const override;
 225   bool IsLoading() const override;
 226   const GURL& GetVisibleURL() const override;
 227   const GURL& GetLastCommittedURL() const override;
 228   GURL GetCurrentURL(URLVerificationTrustLevel* trust_level) const override;
 229   void ShowTransientContentView(CRWContentView* content_view) override;
 230   bool IsShowingWebInterstitial() const override;
 231   WebInterstitial* GetWebInterstitial() const override;
 232   void AddScriptCommandCallback(const ScriptCommandCallback& callback,
 233                                 const std::string& command_prefix) override;
 234   void RemoveScriptCommandCallback(const std::string& command_prefix) override;
 235   id<CRWWebViewProxy> GetWebViewProxy() const override;
 236   int DownloadImage(const GURL& url,
 237                     bool is_favicon,
 238                     uint32_t max_bitmap_size,
 239                     bool bypass_cache,
 240                     const ImageDownloadCallback& callback) override;
 241
 242   // Adds |interstitial|'s view to the web controller's content view.
 243   void ShowWebInterstitial(WebInterstitialImpl* interstitial);
 244
 245   // Called to dismiss the currently-displayed transient content view.
 246   void ClearTransientContentView();
 247
 248   // NavigationManagerDelegate:
 249   void NavigateToPendingEntry() override;
 250   void OnNavigationItemCommitted(
 251       const LoadCommittedDetails& load_details) override;
 252   WebState* GetWebState() override;
 253
 254  protected:
 255   void AddObserver(WebStateObserver* observer) override;
 256   void RemoveObserver(WebStateObserver* observer) override;
 257   void AddPolicyDecider(WebStatePolicyDecider* decider) override;
 258   void RemovePolicyDecider(WebStatePolicyDecider* decider) override;
 259
 260  private:
 261   // Creates a WebUIIOS object for |url| that is owned by the caller. Returns
 262   // nullptr if |url| does not correspond to a WebUI page.
 263   WebUIIOS* CreateWebUIIOS(const GURL& url);
 264
 265   // Updates the HTTP response headers for the main page using the headers
 266   // passed to the OnHttpResponseHeadersReceived() function below.
 267   // GetHttpResponseHeaders() can be used to get the headers.
 268   void UpdateHttpResponseHeaders(const GURL& url);
 269
 270   // Returns true if |web_controller_| has been set.
 271   bool Configured() const;
 272
 273   // Stores whether the web state is currently loading a page.
 274   bool is_loading_;
 275
 276   // The delegate used to pass state to the web contents facade.
 277   WebStateFacadeDelegate* facade_delegate_;
 278
 279   // The CRWWebController that backs and owns this object.
 280   CRWWebController* web_controller_;
 281
 282   NavigationManagerImpl navigation_manager_;
 283
 284   // |web::WebUIIOS| object for the current page if it is a WebUI page that
 285   // uses the web-based WebUI framework, or nullptr otherwise.
 286   scoped_ptr<web::WebUIIOS> web_ui_;
 287
 288   // A list of observers notified when page state changes. Weak references.
 289   base::ObserverList<WebStateObserver, true> observers_;
 290
 291   // All the WebStatePolicyDeciders asked for navigation decision. Weak
 292   // references.
 293   // WebStatePolicyDeciders are semantically different from observers (they
 294   // modify the behavior of the WebState) but are used like observers in the
 295   // code, hence the ObserverList.
 296   base::ObserverList<WebStatePolicyDecider, true> policy_deciders_;
 297
 298   // Map of all the HTTP response headers received, for each URL.
 299   // This map is cleared after each page load, and only the headers of the main
 300   // page are used.
 301   std::map<GURL, scoped_refptr<net::HttpResponseHeaders> >
 302       response_headers_map_;
 303   scoped_refptr<net::HttpResponseHeaders> http_response_headers_;
 304   std::string mime_type_;
 305   std::string content_language_header_;
 306
 307   // Weak pointer to the interstitial page being displayed, if any.
 308   WebInterstitialImpl* interstitial_;
 309
 310   // Returned by reference.
 311   base::string16 empty_string16_;
 312
 313   // Request tracker associted with this object.
 314   scoped_refptr<RequestTrackerImpl> request_tracker_;
 315
 316   // Mode controlling the HTTP cache behavior.
 317   net::RequestTracker::CacheMode cache_mode_;
 318
 319   // A number identifying this object. This number is injected into the user
 320   // agent to allow the network layer to know which web view requests originated
 321   // from.
 322   base::scoped_nsobject<NSString> request_group_id_;
 323
 324   // Callbacks associated to command prefixes.
 325   std::map<std::string, ScriptCommandCallback> script_command_callbacks_;
 326
 327   DISALLOW_COPY_AND_ASSIGN(WebStateImpl);
 328 };
 329
 330 }  // namespace web
 331
 332 #endif  // IOS_WEB_WEB_STATE_WEB_STATE_IMPL_H_