blob: 2df71bf20ad7c550d60443c74ac2ea6427b573f6 [file] [log] [blame]
// Copyright (c) 2012 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 CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_DELEGATE_H_
#define CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_DELEGATE_H_
#include <stdint.h>
#include <string>
#include <vector>
#include "base/callback.h"
#include "build/build_config.h"
#include "content/common/content_export.h"
#include "content/common/drag_event_source_info.h"
#include "content/public/common/drop_data.h"
#include "services/metrics/public/cpp/ukm_recorder.h"
#include "third_party/blink/public/common/manifest/web_display_mode.h"
#include "third_party/blink/public/platform/web_drag_operation.h"
#include "third_party/blink/public/platform/web_input_event.h"
#include "ui/gfx/native_widget_types.h"
#include "ui/gfx/range/range.h"
namespace blink {
class WebMouseWheelEvent;
class WebGestureEvent;
}
namespace gfx {
class Point;
class Size;
}
namespace rappor {
class Sample;
}
namespace content {
class BrowserAccessibilityManager;
class RenderWidgetHostImpl;
class RenderWidgetHostInputEventRouter;
class RenderViewHostDelegateView;
class TextInputManager;
class WebContents;
enum class KeyboardEventProcessingResult;
struct ScreenInfo;
struct NativeWebKeyboardEvent;
//
// RenderWidgetHostDelegate
//
// An interface implemented by an object interested in knowing about the state
// of the RenderWidgetHost.
class CONTENT_EXPORT RenderWidgetHostDelegate {
public:
// The RenderWidgetHost has just been created.
virtual void RenderWidgetCreated(RenderWidgetHostImpl* render_widget_host) {}
// The RenderWidgetHost is going to be deleted.
virtual void RenderWidgetDeleted(RenderWidgetHostImpl* render_widget_host) {}
// The RenderWidgetHost got the focus.
virtual void RenderWidgetGotFocus(RenderWidgetHostImpl* render_widget_host) {}
// If a main frame navigation is in progress, this will return the zoom level
// for the pending page. Otherwise, this returns the zoom level for the
// current page. Note that subframe navigations do not affect the zoom level,
// which is tracked at the level of the page.
virtual double GetPendingPageZoomLevel() const;
// The RenderWidgetHost lost the focus.
virtual void RenderWidgetLostFocus(
RenderWidgetHostImpl* render_widget_host) {}
// The RenderWidget was resized.
virtual void RenderWidgetWasResized(RenderWidgetHostImpl* render_widget_host,
const ScreenInfo& screen_info,
bool width_changed) {}
// The contents auto-resized and the container should match it.
virtual void ResizeDueToAutoResize(RenderWidgetHostImpl* render_widget_host,
const gfx::Size& new_size) {}
// Callback to give the browser a chance to handle the specified keyboard
// event before sending it to the renderer. See enum for details on return
// value.
virtual KeyboardEventProcessingResult PreHandleKeyboardEvent(
const NativeWebKeyboardEvent& event);
// Callback to inform the browser that the renderer did not process the
// specified events. This gives an opportunity to the browser to process the
// event (used for keyboard shortcuts).
virtual void HandleKeyboardEvent(const NativeWebKeyboardEvent& event) {}
// Callback to inform the browser that the renderer did not process the
// specified mouse wheel event. Returns true if the browser has handled
// the event itself.
virtual bool HandleWheelEvent(const blink::WebMouseWheelEvent& event);
// Notification that an input event from the user was dispatched to the
// widget.
virtual void DidReceiveInputEvent(RenderWidgetHostImpl* render_widget_host,
const blink::WebInputEvent::Type type) {}
// Callback to give the browser a chance to handle the specified gesture
// event before sending it to the renderer.
// Returns true if the |event| was handled.
virtual bool PreHandleGestureEvent(const blink::WebGestureEvent& event);
// Notifies that screen rects were sent to renderer process.
virtual void DidSendScreenRects(RenderWidgetHostImpl* rwh) {}
// Get the root BrowserAccessibilityManager for this frame tree.
virtual BrowserAccessibilityManager* GetRootBrowserAccessibilityManager();
// Get the root BrowserAccessibilityManager for this frame tree,
// or create it if it doesn't exist.
virtual BrowserAccessibilityManager*
GetOrCreateRootBrowserAccessibilityManager();
// Send OS Cut/Copy/Paste actions to the focused frame.
virtual void ExecuteEditCommand(
const std::string& command,
const base::Optional<base::string16>& value) = 0;
virtual void Cut() = 0;
virtual void Copy() = 0;
virtual void Paste() = 0;
virtual void SelectAll() = 0;
// Requests the renderer to move the selection extent to a new position.
virtual void MoveRangeSelectionExtent(const gfx::Point& extent) {}
// Requests the renderer to select the region between two points in the
// currently focused frame.
virtual void SelectRange(const gfx::Point& base, const gfx::Point& extent) {}
#if defined(OS_MACOSX)
virtual void DidChangeTextSelection(const base::string16& text,
const gfx::Range& range) {}
#endif
// Request the renderer to Move the caret to the new position.
virtual void MoveCaret(const gfx::Point& extent) {}
virtual RenderWidgetHostInputEventRouter* GetInputEventRouter();
// Send page-level focus state to all SiteInstances involved in rendering the
// current FrameTree, not including the main frame's SiteInstance.
virtual void ReplicatePageFocus(bool is_focused) {}
// Get the focused RenderWidgetHost associated with |receiving_widget|. A
// RenderWidgetHostView, upon receiving a keyboard event, will pass its
// RenderWidgetHost to this function to determine who should ultimately
// consume the event. This facilitates keyboard event routing with
// out-of-process iframes, where multiple RenderWidgetHosts may be involved
// in rendering a page, yet keyboard events all arrive at the main frame's
// RenderWidgetHostView. When a main frame's RenderWidgetHost is passed in,
// the function returns the focused frame that should consume keyboard
// events. In all other cases, the function returns back |receiving_widget|.
virtual RenderWidgetHostImpl* GetFocusedRenderWidgetHost(
RenderWidgetHostImpl* receiving_widget);
// Notification that the renderer has become unresponsive. The
// delegate can use this notification to show a warning to the user.
// See also WebContentsDelegate::RendererUnresponsive.
virtual void RendererUnresponsive(
RenderWidgetHostImpl* render_widget_host,
base::RepeatingClosure hang_monitor_restarter) {}
// Notification that a previously unresponsive renderer has become
// responsive again. The delegate can use this notification to end the
// warning shown to the user.
virtual void RendererResponsive(RenderWidgetHostImpl* render_widget_host) {}
// Requests to lock the mouse. Once the request is approved or rejected,
// GotResponseToLockMouseRequest() will be called on the requesting render
// widget host. |privileged| means that the request is always granted, used
// for Pepper Flash.
virtual void RequestToLockMouse(RenderWidgetHostImpl* render_widget_host,
bool user_gesture,
bool last_unlocked_by_target,
bool privileged) {}
// Returns whether the associated tab is in fullscreen mode.
virtual bool IsFullscreenForCurrentTab() const;
// Returns the display mode for the view.
virtual blink::WebDisplayMode GetDisplayMode(
RenderWidgetHostImpl* render_widget_host) const;
// Notification that the widget has lost capture.
virtual void LostCapture(RenderWidgetHostImpl* render_widget_host) {}
// Notification that the widget has lost the mouse lock.
virtual void LostMouseLock(RenderWidgetHostImpl* render_widget_host) {}
// Returns true if |render_widget_host| holds the mouse lock.
virtual bool HasMouseLock(RenderWidgetHostImpl* render_widget_host);
// Returns the widget that holds the mouse lock or nullptr if the mouse isn't
// locked.
virtual RenderWidgetHostImpl* GetMouseLockWidget();
// Requests to lock the keyboard. Once the request is approved or rejected,
// GotResponseToKeyboardLockRequest() will be called on the requesting render
// widget host.
virtual bool RequestKeyboardLock(RenderWidgetHostImpl* render_widget_host,
bool esc_key_locked);
// Cancels a previous keyboard lock request.
virtual void CancelKeyboardLock(RenderWidgetHostImpl* render_widget_host) {}
// Returns the widget that holds the keyboard lock or nullptr if not locked.
virtual RenderWidgetHostImpl* GetKeyboardLockWidget();
// Called when the visibility of the RenderFrameProxyHost in outer
// WebContents changes. This method is only called on an inner WebContents and
// will eventually notify all the RenderWidgetHostViews belonging to that
// WebContents.
virtual void OnRenderFrameProxyVisibilityChanged(bool visible) {}
// Update the renderer's cache of the screen rect of the view and window.
virtual void SendScreenRects() {}
// Returns the TextInputManager tracking text input state.
virtual TextInputManager* GetTextInputManager();
// Returns true if this RenderWidgetHost should remain hidden. This is used by
// the RenderWidgetHost to ask the delegate if it can be shown in the event of
// something other than the WebContents attempting to enable visibility of
// this RenderWidgetHost.
virtual bool IsHidden();
// Returns the associated RenderViewHostDelegateView*, if possible.
virtual RenderViewHostDelegateView* GetDelegateView();
// Returns the current Flash fullscreen RenderWidgetHostImpl if any. This is
// not intended for use with other types of fullscreen, such as HTML
// fullscreen, and will return nullptr for those cases.
virtual RenderWidgetHostImpl* GetFullscreenRenderWidgetHost() const;
// Allow the delegate to handle the cursor update. Returns true if handled.
virtual bool OnUpdateDragCursor();
// Returns true if the provided RenderWidgetHostImpl matches the current
// RenderWidgetHost on the main frame, and false otherwise.
virtual bool IsWidgetForMainFrame(RenderWidgetHostImpl*);
// Inner WebContents Helpers -------------------------------------------------
//
// These functions are helpers in managing a hierharchy of WebContents
// involved in rendering inner WebContents.
// Get the RenderWidgetHost that should receive page level focus events. This
// will be the widget that is rendering the main frame of the currently
// focused WebContents.
virtual RenderWidgetHostImpl* GetRenderWidgetHostWithPageFocus();
// In cases with multiple RenderWidgetHosts involved in rendering a page, only
// one widget should be focused and active. This ensures that
// |render_widget_host| is focused and that its owning WebContents is also
// the focused WebContents.
virtual void FocusOwningWebContents(
RenderWidgetHostImpl* render_widget_host) {}
// Augment a Rappor sample with eTLD+1 context. The caller is still
// responsible for logging the sample to the RapporService. Returns false
// if the eTLD+1 is not known for |render_widget_host|.
virtual bool AddDomainInfoToRapporSample(rappor::Sample* sample);
// Get the UKM source ID for current content. This is used for providing
// data about the content to the URL-keyed metrics service.
// Note: This is also exposed by the RenderFrameHostDelegate.
virtual ukm::SourceId GetUkmSourceIdForLastCommittedSource() const;
// Notifies the delegate that a focused editable element has been touched
// inside this RenderWidgetHost. If |editable| is true then the focused
// element accepts text input.
virtual void FocusedNodeTouched(bool editable) {}
// Return this object cast to a WebContents, if it is one. If the object is
// not a WebContents, returns nullptr.
virtual WebContents* GetAsWebContents();
// Gets the size set by a top-level frame with auto-resize enabled.
virtual gfx::Size GetAutoResizeSize();
// Reset the auto-size value, to indicate that auto-size is no longer active.
virtual void ResetAutoResizeSize() {}
// Returns true if there is context menu shown on page.
virtual bool IsShowingContextMenuOnPage() const;
protected:
virtual ~RenderWidgetHostDelegate() {}
};
} // namespace content
#endif // CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_DELEGATE_H_