diff options
Diffstat (limited to 'chromium/extensions/browser/guest_view/web_view/web_view_guest.h')
| -rw-r--r-- | chromium/extensions/browser/guest_view/web_view/web_view_guest.h | 389 |
1 files changed, 389 insertions, 0 deletions
diff --git a/chromium/extensions/browser/guest_view/web_view/web_view_guest.h b/chromium/extensions/browser/guest_view/web_view/web_view_guest.h new file mode 100644 index 00000000000..d1baac5b64c --- /dev/null +++ b/chromium/extensions/browser/guest_view/web_view/web_view_guest.h @@ -0,0 +1,389 @@ +// Copyright 2014 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. + +#ifndef EXTENSIONS_BROWSER_GUEST_VIEW_WEB_VIEW_WEB_VIEW_GUEST_H_ +#define EXTENSIONS_BROWSER_GUEST_VIEW_WEB_VIEW_WEB_VIEW_GUEST_H_ + +#include <stdint.h> + +#include <vector> + +#include "base/macros.h" +#include "base/observer_list.h" +#include "components/guest_view/browser/guest_view.h" +#include "content/public/browser/javascript_dialog_manager.h" +#include "content/public/browser/notification_observer.h" +#include "content/public/browser/notification_registrar.h" +#include "extensions/browser/guest_view/web_view/javascript_dialog_helper.h" +#include "extensions/browser/guest_view/web_view/web_view_find_helper.h" +#include "extensions/browser/guest_view/web_view/web_view_guest_delegate.h" +#include "extensions/browser/guest_view/web_view/web_view_permission_helper.h" +#include "extensions/browser/guest_view/web_view/web_view_permission_types.h" +#include "extensions/browser/script_executor.h" + +namespace blink { +struct WebFindOptions; +} // nanespace blink + +namespace content { +struct GlobalRequestID; +} // namespace content + +namespace extensions { + +class WebViewInternalFindFunction; + +// A WebViewGuest provides the browser-side implementation of the <webview> API +// and manages the dispatch of <webview> extension events. WebViewGuest is +// created on attachment. That is, when a guest WebContents is associated with +// a particular embedder WebContents. This happens on either initial navigation +// or through the use of the New Window API, when a new window is attached to +// a particular <webview>. +class WebViewGuest : public guest_view::GuestView<WebViewGuest>, + public content::NotificationObserver { + public: + // Clean up state when this GuestView is being destroyed. See + // GuestViewBase::CleanUp(). + static void CleanUp(content::BrowserContext* browser_context, + int embedder_process_id, + int view_instance_id); + + static GuestViewBase* Create(content::WebContents* owner_web_contents); + + // For WebViewGuest, we create special guest processes, which host the + // tag content separately from the main application that embeds the tag. + // A <webview> can specify both the partition name and whether the storage + // for that partition should be persisted. Each tag gets a SiteInstance with + // a specially formatted URL, based on the application it is hosted by and + // the partition requested by it. The format for that URL is: + // chrome-guest://partition_domain/persist?partition_name + static bool GetGuestPartitionConfigForSite(const GURL& site, + std::string* partition_domain, + std::string* partition_name, + bool* in_memory); + + // Returns the WebView partition ID associated with the render process + // represented by |render_process_host|, if any. Otherwise, an empty string is + // returned. + static std::string GetPartitionID( + const content::RenderProcessHost* render_process_host); + + static const char Type[]; + + // Returns the stored rules registry ID of the given webview. Will generate + // an ID for the first query. + static int GetOrGenerateRulesRegistryID( + int embedder_process_id, + int web_view_instance_id); + + // Get the current zoom. + double GetZoom() const; + + // Get the current zoom mode. + ui_zoom::ZoomController::ZoomMode GetZoomMode(); + + // Request navigating the guest to the provided |src| URL. + void NavigateGuest(const std::string& src, bool force_navigation); + + // Shows the context menu for the guest. + void ShowContextMenu(int request_id); + + // Sets the frame name of the guest. + void SetName(const std::string& name); + const std::string& name() { return name_; } + + // Set the zoom factor. + void SetZoom(double zoom_factor); + + // Set the zoom mode. + void SetZoomMode(ui_zoom::ZoomController::ZoomMode zoom_mode); + + void SetAllowScaling(bool allow); + bool allow_scaling() const { return allow_scaling_; } + + // Sets the transparency of the guest. + void SetAllowTransparency(bool allow); + bool allow_transparency() const { return allow_transparency_; } + + // Loads a data URL with a specified base URL and virtual URL. + bool LoadDataWithBaseURL(const std::string& data_url, + const std::string& base_url, + const std::string& virtual_url, + std::string* error); + + // Begin or continue a find request. + void StartFind(const base::string16& search_text, + const blink::WebFindOptions& options, + scoped_refptr<WebViewInternalFindFunction> find_function); + + // Conclude a find request to clear highlighting. + void StopFinding(content::StopFindAction); + + // If possible, navigate the guest to |relative_index| entries away from the + // current navigation entry. Returns true on success. + bool Go(int relative_index); + + // Reload the guest. + void Reload(); + + // Overrides the user agent for this guest. + // This affects subsequent guest navigations. + void SetUserAgentOverride(const std::string& user_agent_override); + + // Stop loading the guest. + void Stop(); + + // Kill the guest process. + void Terminate(); + + // Clears data in the storage partition of this guest. + // + // Partition data that are newer than |removal_since| will be removed. + // |removal_mask| corresponds to bitmask in StoragePartition::RemoveDataMask. + bool ClearData(const base::Time remove_since, + uint32_t removal_mask, + const base::Closure& callback); + + ScriptExecutor* script_executor() { return script_executor_.get(); } + + private: + friend class WebViewPermissionHelper; + + explicit WebViewGuest(content::WebContents* owner_web_contents); + + ~WebViewGuest() override; + + void ClearDataInternal(const base::Time remove_since, + uint32_t removal_mask, + const base::Closure& callback); + + void OnWebViewNewWindowResponse(int new_window_instance_id, + bool allow, + const std::string& user_input); + + void OnFullscreenPermissionDecided(bool allowed, + const std::string& user_input); + bool GuestMadeEmbedderFullscreen() const; + void SetFullscreenState(bool is_fullscreen); + + // GuestViewBase implementation. + bool CanRunInDetachedState() const final; + void CreateWebContents(const base::DictionaryValue& create_params, + const WebContentsCreatedCallback& callback) final; + void DidAttachToEmbedder() final; + void DidDropLink(const GURL& url) final; + void DidInitialize(const base::DictionaryValue& create_params) final; + void EmbedderFullscreenToggled(bool entered_fullscreen) final; + void FindReply(content::WebContents* source, + int request_id, + int number_of_matches, + const gfx::Rect& selection_rect, + int active_match_ordinal, + bool final_update) final; + const char* GetAPINamespace() const final; + int GetTaskPrefix() const final; + void GuestDestroyed() final; + void GuestReady() final; + void GuestSizeChangedDueToAutoSize(const gfx::Size& old_size, + const gfx::Size& new_size) final; + void GuestViewDidStopLoading() final; + void GuestZoomChanged(double old_zoom_level, double new_zoom_level) final; + bool IsAutoSizeSupported() const final; + void SetContextMenuPosition(const gfx::Point& position) final; + void SignalWhenReady(const base::Closure& callback) final; + bool ShouldHandleFindRequestsForEmbedder() const final; + void WillAttachToEmbedder() final; + void WillDestroy() final; + + // NotificationObserver implementation. + void Observe(int type, + const content::NotificationSource& source, + const content::NotificationDetails& details) final; + + // WebContentsDelegate implementation. + bool AddMessageToConsole(content::WebContents* source, + int32_t level, + const base::string16& message, + int32_t line_no, + const base::string16& source_id) final; + void CloseContents(content::WebContents* source) final; + bool HandleContextMenu(const content::ContextMenuParams& params) final; + void HandleKeyboardEvent(content::WebContents* source, + const content::NativeWebKeyboardEvent& event) final; + void LoadProgressChanged(content::WebContents* source, double progress) final; + bool PreHandleGestureEvent(content::WebContents* source, + const blink::WebGestureEvent& event) final; + void RendererResponsive(content::WebContents* source) final; + void RendererUnresponsive(content::WebContents* source) final; + void RequestMediaAccessPermission( + content::WebContents* source, + const content::MediaStreamRequest& request, + const content::MediaResponseCallback& callback) final; + void RequestPointerLockPermission( + bool user_gesture, + bool last_unlocked_by_target, + const base::Callback<void(bool)>& callback) final; + bool CheckMediaAccessPermission(content::WebContents* source, + const GURL& security_origin, + content::MediaStreamType type) final; + void CanDownload(const GURL& url, + const std::string& request_method, + const base::Callback<void(bool)>& callback) final; + content::JavaScriptDialogManager* GetJavaScriptDialogManager( + content::WebContents* source) final; + void AddNewContents(content::WebContents* source, + content::WebContents* new_contents, + WindowOpenDisposition disposition, + const gfx::Rect& initial_rect, + bool user_gesture, + bool* was_blocked) final; + content::WebContents* OpenURLFromTab( + content::WebContents* source, + const content::OpenURLParams& params) final; + void WebContentsCreated(content::WebContents* source_contents, + int opener_render_frame_id, + const std::string& frame_name, + const GURL& target_url, + content::WebContents* new_contents) final; + void EnterFullscreenModeForTab(content::WebContents* web_contents, + const GURL& origin) final; + void ExitFullscreenModeForTab(content::WebContents* web_contents) final; + bool IsFullscreenForTabOrPending( + const content::WebContents* web_contents) const final; + + // WebContentsObserver implementation. + void DidCommitProvisionalLoadForFrame( + content::RenderFrameHost* render_frame_host, + const GURL& url, + ui::PageTransition transition_type) final; + void DidFailProvisionalLoad(content::RenderFrameHost* render_frame_host, + const GURL& validated_url, + int error_code, + const base::string16& error_description, + bool was_ignored_by_handler) final; + void DidStartProvisionalLoadForFrame( + content::RenderFrameHost* render_frame_host, + const GURL& validated_url, + bool is_error_page, + bool is_iframe_srcdoc) final; + void RenderProcessGone(base::TerminationStatus status) final; + void UserAgentOverrideSet(const std::string& user_agent) final; + void FrameNameChanged(content::RenderFrameHost* render_frame_host, + const std::string& name) final; + + // Informs the embedder of a frame name change. + void ReportFrameNameChange(const std::string& name); + + // Called after the load handler is called in the guest's main frame. + void LoadHandlerCalled(); + + // Called when a redirect notification occurs. + void LoadRedirect(const GURL& old_url, + const GURL& new_url, + bool is_top_level); + + void PushWebViewStateToIOThread(); + static void RemoveWebViewStateFromIOThread( + content::WebContents* web_contents); + + // Loads the |url| provided. |force_navigation| indicates whether to reload + // the content if the provided |url| matches the current page of the guest. + void LoadURLWithParams( + const GURL& url, + const content::Referrer& referrer, + ui::PageTransition transition_type, + bool force_navigation); + + void RequestNewWindowPermission( + WindowOpenDisposition disposition, + const gfx::Rect& initial_bounds, + bool user_gesture, + content::WebContents* new_contents); + + // Requests resolution of a potentially relative URL. + GURL ResolveURL(const std::string& src); + + // Notification that a load in the guest resulted in abort. Note that |url| + // may be invalid. + void LoadAbort(bool is_top_level, + const GURL& url, + int error_code, + const std::string& error_type); + + // Creates a new guest window owned by this WebViewGuest. + void CreateNewGuestWebViewWindow(const content::OpenURLParams& params); + + void NewGuestWebViewCallback(const content::OpenURLParams& params, + content::WebContents* guest_web_contents); + + bool HandleKeyboardShortcuts(const content::NativeWebKeyboardEvent& event); + + void ApplyAttributes(const base::DictionaryValue& params); + + // Identifies the set of rules registries belonging to this guest. + int rules_registry_id_; + + // Handles find requests and replies for the webview find API. + WebViewFindHelper find_helper_; + + base::ObserverList<ScriptExecutionObserver> script_observers_; + scoped_ptr<ScriptExecutor> script_executor_; + + content::NotificationRegistrar notification_registrar_; + + // True if the user agent is overridden. + bool is_overriding_user_agent_; + + // Stores the window name of the main frame of the guest. + std::string name_; + + // Stores whether the contents of the guest can be transparent. + bool allow_transparency_; + + // Stores the src URL of the WebView. + GURL src_; + + // Handles the JavaScript dialog requests. + JavaScriptDialogHelper javascript_dialog_helper_; + + // Handles permission requests. + scoped_ptr<WebViewPermissionHelper> web_view_permission_helper_; + + scoped_ptr<WebViewGuestDelegate> web_view_guest_delegate_; + + // Tracks the name, and target URL of the new window. Once the first + // navigation commits, we no longer track this information. + struct NewWindowInfo { + GURL url; + std::string name; + bool changed; + NewWindowInfo(const GURL& url, const std::string& name) : + url(url), + name(name), + changed(false) {} + }; + + using PendingWindowMap = std::map<WebViewGuest*, NewWindowInfo>; + PendingWindowMap pending_new_windows_; + + // Determines if this guest accepts pinch-zoom gestures. + bool allow_scaling_; + bool is_guest_fullscreen_; + bool is_embedder_fullscreen_; + bool last_fullscreen_permission_was_allowed_by_embedder_; + + // Tracks whether the webview has a pending zoom from before the first + // navigation. This will be equal to 0 when there is no pending zoom. + double pending_zoom_factor_; + + // This is used to ensure pending tasks will not fire after this object is + // destroyed. + base::WeakPtrFactory<WebViewGuest> weak_ptr_factory_; + + DISALLOW_COPY_AND_ASSIGN(WebViewGuest); +}; + +} // namespace extensions + +#endif // EXTENSIONS_BROWSER_GUEST_VIEW_WEB_VIEW_WEB_VIEW_GUEST_H_ |