| // 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_VIEW_MAC_H_ |
| #define CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_MAC_H_ |
| |
| #import <Cocoa/Cocoa.h> |
| |
| #include <string> |
| #include <vector> |
| |
| #include "base/mac/scoped_nsobject.h" |
| #include "base/macros.h" |
| #include "base/memory/weak_ptr.h" |
| #include "base/time/time.h" |
| #include "components/viz/common/surfaces/surface_id.h" |
| #include "content/browser/renderer_host/browser_compositor_view_mac.h" |
| #include "content/browser/renderer_host/input/mouse_wheel_phase_handler.h" |
| #include "content/browser/renderer_host/render_widget_host_ns_view_client_helper.h" |
| #include "content/browser/renderer_host/render_widget_host_view_base.h" |
| #include "content/browser/renderer_host/text_input_manager.h" |
| #include "content/common/content_export.h" |
| #include "content/common/render_widget_host_ns_view.mojom.h" |
| #include "ipc/ipc_sender.h" |
| #include "mojo/public/cpp/bindings/associated_binding.h" |
| #include "ui/accelerated_widget_mac/accelerated_widget_mac.h" |
| #include "ui/accelerated_widget_mac/display_link_mac.h" |
| #include "ui/base/cocoa/accessibility_focus_overrider.h" |
| #include "ui/base/cocoa/remote_layer_api.h" |
| #include "ui/events/gesture_detection/filtered_gesture_provider.h" |
| |
| namespace ui { |
| enum class DomCode; |
| class ScopedPasswordInputEnabler; |
| } |
| |
| @protocol RenderWidgetHostViewMacDelegate; |
| |
| @class NSAccessibilityRemoteUIElement; |
| @class RenderWidgetHostViewCocoa; |
| |
| namespace content { |
| |
| class CursorManager; |
| class NSViewBridgeFactoryHost; |
| class RenderWidgetHost; |
| class RenderWidgetHostNSViewBridgeLocal; |
| class RenderWidgetHostViewMac; |
| class WebContents; |
| class WebCursor; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // RenderWidgetHostViewMac |
| // |
| // An object representing the "View" of a rendered web page. This object is |
| // responsible for displaying the content of the web page, and integrating with |
| // the Cocoa view system. It is the implementation of the RenderWidgetHostView |
| // that the cross-platform RenderWidgetHost object uses |
| // to display the data. |
| // |
| // Comment excerpted from render_widget_host.h: |
| // |
| // "The lifetime of the RenderWidgetHost* is tied to the render process. |
| // If the render process dies, the RenderWidgetHost* goes away and all |
| // references to it must become NULL." |
| // |
| // RenderWidgetHostView class hierarchy described in render_widget_host_view.h. |
| class CONTENT_EXPORT RenderWidgetHostViewMac |
| : public RenderWidgetHostViewBase, |
| public RenderWidgetHostNSViewClientHelper, |
| public mojom::RenderWidgetHostNSViewClient, |
| public BrowserCompositorMacClient, |
| public TextInputManager::Observer, |
| public ui::GestureProviderClient, |
| public ui::AcceleratedWidgetMacNSView, |
| public ui::AccessibilityFocusOverrider::Client, |
| public IPC::Sender { |
| public: |
| // The view will associate itself with the given widget. The native view must |
| // be hooked up immediately to the view hierarchy, or else when it is |
| // deleted it will delete this out from under the caller. |
| // |
| // When |is_guest_view_hack| is true, this view isn't really the view for |
| // the |widget|, a RenderWidgetHostViewGuest is. |
| // TODO(lazyboy): Remove |is_guest_view_hack| once BrowserPlugin has migrated |
| // to use RWHVChildFrame (http://crbug.com/330264). |
| RenderWidgetHostViewMac(RenderWidgetHost* widget, bool is_guest_view_hack); |
| |
| RenderWidgetHostViewCocoa* cocoa_view() const; |
| |
| // |delegate| is used to separate out the logic from the NSResponder delegate. |
| // |delegate| is retained by this class. |
| // |delegate| should be set at most once. |
| CONTENT_EXPORT void SetDelegate( |
| NSObject<RenderWidgetHostViewMacDelegate>* delegate); |
| |
| // RenderWidgetHostView implementation. |
| void InitAsChild(gfx::NativeView parent_view) override; |
| void SetSize(const gfx::Size& size) override; |
| void SetBounds(const gfx::Rect& rect) override; |
| gfx::NativeView GetNativeView() const override; |
| gfx::NativeViewAccessible GetNativeViewAccessible() override; |
| bool HasFocus() const override; |
| void Show() override; |
| void Hide() override; |
| bool IsShowing() override; |
| void WasUnOccluded() override; |
| void WasOccluded() override; |
| gfx::Rect GetViewBounds() const override; |
| bool IsMouseLocked() override; |
| void SetActive(bool active) override; |
| void ShowDefinitionForSelection() override; |
| void SpeakSelection() override; |
| void SetNeedsBeginFrames(bool needs_begin_frames) override; |
| void GetScreenInfo(ScreenInfo* screen_info) const override; |
| void SetWantsAnimateOnlyBeginFrames() override; |
| void TakeFallbackContentFrom(RenderWidgetHostView* view) override; |
| |
| // Implementation of RenderWidgetHostViewBase. |
| void InitAsPopup(RenderWidgetHostView* parent_host_view, |
| const gfx::Rect& pos) override; |
| void InitAsFullscreen(RenderWidgetHostView* reference_host_view) override; |
| void Focus() override; |
| void UpdateCursor(const WebCursor& cursor) override; |
| void DisplayCursor(const WebCursor& cursor) override; |
| CursorManager* GetCursorManager() override; |
| void OnDidNavigateMainFrameToNewPage() override; |
| void SetIsLoading(bool is_loading) override; |
| void RenderProcessGone(base::TerminationStatus status, |
| int error_code) override; |
| void Destroy() override; |
| void SetTooltipText(const base::string16& tooltip_text) override; |
| void DisplayTooltipText(const base::string16& tooltip_text) override; |
| gfx::Size GetRequestedRendererSize() const override; |
| uint32_t GetCaptureSequenceNumber() const override; |
| bool IsSurfaceAvailableForCopy() const override; |
| void CopyFromSurface( |
| const gfx::Rect& src_rect, |
| const gfx::Size& output_size, |
| base::OnceCallback<void(const SkBitmap&)> callback) override; |
| void EnsureSurfaceSynchronizedForWebTest() override; |
| void FocusedNodeChanged(bool is_editable_node, |
| const gfx::Rect& node_bounds_in_screen) override; |
| void DidCreateNewRendererCompositorFrameSink( |
| viz::mojom::CompositorFrameSinkClient* renderer_compositor_frame_sink) |
| override; |
| void SubmitCompositorFrame( |
| const viz::LocalSurfaceId& local_surface_id, |
| viz::CompositorFrame frame, |
| base::Optional<viz::HitTestRegionList> hit_test_region_list) override; |
| void OnDidNotProduceFrame(const viz::BeginFrameAck& ack) override; |
| void ClearCompositorFrame() override; |
| void ResetFallbackToFirstNavigationSurface() override; |
| bool RequestRepaintForTesting() override; |
| BrowserAccessibilityManager* CreateBrowserAccessibilityManager( |
| BrowserAccessibilityDelegate* delegate, bool for_root_frame) override; |
| gfx::NativeViewAccessible AccessibilityGetNativeViewAccessible() override; |
| gfx::NativeViewAccessible AccessibilityGetNativeViewAccessibleForWindow() |
| override; |
| base::Optional<SkColor> GetBackgroundColor() const override; |
| |
| void SetParentUiLayer(ui::Layer* parent_ui_layer) override; |
| void TransformPointToRootSurface(gfx::PointF* point) override; |
| gfx::Rect GetBoundsInRootWindow() override; |
| viz::ScopedSurfaceIdAllocator DidUpdateVisualProperties( |
| const cc::RenderFrameMetadata& metadata) override; |
| void DidNavigate() override; |
| |
| bool LockMouse() override; |
| void UnlockMouse() override; |
| bool LockKeyboard(base::Optional<base::flat_set<ui::DomCode>> codes) override; |
| void UnlockKeyboard() override; |
| bool IsKeyboardLocked() override; |
| base::flat_map<std::string, std::string> GetKeyboardLayoutMap() override; |
| void GestureEventAck(const blink::WebGestureEvent& event, |
| InputEventAckState ack_result) override; |
| void ProcessAckedTouchEvent(const TouchEventWithLatencyInfo& touch, |
| InputEventAckState ack_result) override; |
| |
| void DidOverscroll(const ui::DidOverscrollParams& params) override; |
| |
| std::unique_ptr<SyntheticGestureTarget> CreateSyntheticGestureTarget() |
| override; |
| |
| const viz::FrameSinkId& GetFrameSinkId() const override; |
| const viz::LocalSurfaceIdAllocation& GetLocalSurfaceIdAllocation() |
| const override; |
| // Returns true when we can do SurfaceHitTesting for the event type. |
| bool ShouldRouteEvent(const blink::WebInputEvent& event) const; |
| // This method checks |event| to see if a GesturePinch or double tap event |
| // can be routed according to ShouldRouteEvent, and if not, sends it directly |
| // to the view's RenderWidgetHost. |
| // By not just defaulting to sending events that change the page scale to the |
| // main frame, we allow the events to be targeted to an oopif subframe, in |
| // case some consumer, such as PDF or maps, wants to intercept them and |
| // implement a custom behavior. |
| void SendTouchpadZoomEvent(const blink::WebGestureEvent* event); |
| |
| // Inject synthetic touch events. |
| void InjectTouchEvent(const blink::WebTouchEvent& event, |
| const ui::LatencyInfo& latency_info) override; |
| |
| bool TransformPointToLocalCoordSpaceLegacy( |
| const gfx::PointF& point, |
| const viz::SurfaceId& original_surface, |
| gfx::PointF* transformed_point) override; |
| bool TransformPointToCoordSpaceForView( |
| const gfx::PointF& point, |
| RenderWidgetHostViewBase* target_view, |
| gfx::PointF* transformed_point, |
| viz::EventSource source = viz::EventSource::ANY) override; |
| viz::FrameSinkId GetRootFrameSinkId() override; |
| viz::SurfaceId GetCurrentSurfaceId() const override; |
| |
| // TextInputManager::Observer implementation. |
| void OnUpdateTextInputStateCalled(TextInputManager* text_input_manager, |
| RenderWidgetHostViewBase* updated_view, |
| bool did_update_state) override; |
| void OnImeCancelComposition(TextInputManager* text_input_manager, |
| RenderWidgetHostViewBase* updated_view) override; |
| void OnImeCompositionRangeChanged( |
| TextInputManager* text_input_manager, |
| RenderWidgetHostViewBase* updated_view) override; |
| void OnSelectionBoundsChanged( |
| TextInputManager* text_input_manager, |
| RenderWidgetHostViewBase* updated_view) override; |
| void OnTextSelectionChanged(TextInputManager* text_input_manager, |
| RenderWidgetHostViewBase* updated_view) override; |
| |
| // ui::GestureProviderClient implementation. |
| void OnGestureEvent(const ui::GestureEventData& gesture) override; |
| |
| // RenderFrameMetadataProvider::Observer |
| void OnRenderFrameMetadataChangedAfterActivation() override; |
| |
| // IPC::Sender implementation. |
| bool Send(IPC::Message* message) override; |
| |
| void SetTextInputActive(bool active); |
| |
| // Returns true and stores first rectangle for character range if the |
| // requested |range| is already cached, otherwise returns false. |
| // Exposed for testing. |
| CONTENT_EXPORT bool GetCachedFirstRectForCharacterRange( |
| const gfx::Range& requested_range, |
| gfx::Rect* rect, |
| gfx::Range* actual_range); |
| |
| // Returns true if there is line break in |range| and stores line breaking |
| // point to |line_breaking_point|. The |line_break_point| is valid only if |
| // this function returns true. |
| bool GetLineBreakIndex(const std::vector<gfx::Rect>& bounds, |
| const gfx::Range& range, |
| size_t* line_break_point); |
| |
| // Returns composition character boundary rectangle. The |range| is |
| // composition based range. Also stores |actual_range| which is corresponding |
| // to actually used range for returned rectangle. |
| gfx::Rect GetFirstRectForCompositionRange(const gfx::Range& range, |
| gfx::Range* actual_range); |
| |
| // Converts from given whole character range to composition oriented range. If |
| // the conversion failed, return gfx::Range::InvalidRange. |
| gfx::Range ConvertCharacterRangeToCompositionRange( |
| const gfx::Range& request_range); |
| |
| WebContents* GetWebContents(); |
| |
| // Set the color of the background CALayer shown when no content is ready to |
| // see. |
| void SetBackgroundLayerColor(SkColor color); |
| |
| bool HasPendingWheelEndEventForTesting() { |
| return mouse_wheel_phase_handler_.HasPendingWheelEndEvent(); |
| } |
| |
| // These member variables should be private, but the associated ObjC class |
| // needs access to them and can't be made a friend. |
| |
| // Delegated frame management and compositor interface. |
| std::unique_ptr<BrowserCompositorMac> browser_compositor_; |
| BrowserCompositorMac* BrowserCompositor() const { |
| return browser_compositor_.get(); |
| } |
| |
| // Set when the currently-displayed frame is the minimum scale. Used to |
| // determine if pinch gestures need to be thresholded. |
| bool page_at_minimum_scale_; |
| |
| MouseWheelPhaseHandler mouse_wheel_phase_handler_; |
| |
| // Used to set the mouse_wheel_phase_handler_ timer timeout for testing. |
| void set_mouse_wheel_wheel_phase_handler_timeout(base::TimeDelta timeout) { |
| mouse_wheel_phase_handler_.set_mouse_wheel_end_dispatch_timeout(timeout); |
| } |
| |
| // Update the size, scale factor, color profile, vsync parameters, and any |
| // other properties of the NSView or its NSScreen. Propagate these to the |
| // RenderWidgetHostImpl as well. |
| void UpdateNSViewAndDisplayProperties(); |
| |
| // RenderWidgetHostNSViewClientHelper implementation. |
| id GetRootBrowserAccessibilityElement() override; |
| id GetFocusedBrowserAccessibilityElement() override; |
| void SetAccessibilityWindow(NSWindow* window) override; |
| void ForwardKeyboardEvent(const NativeWebKeyboardEvent& key_event, |
| const ui::LatencyInfo& latency_info) override; |
| void ForwardKeyboardEventWithCommands( |
| const NativeWebKeyboardEvent& key_event, |
| const ui::LatencyInfo& latency_info, |
| const std::vector<EditCommand>& commands) override; |
| void RouteOrProcessMouseEvent(const blink::WebMouseEvent& web_event) override; |
| void RouteOrProcessTouchEvent(const blink::WebTouchEvent& web_event) override; |
| void RouteOrProcessWheelEvent( |
| const blink::WebMouseWheelEvent& web_event) override; |
| void ForwardMouseEvent(const blink::WebMouseEvent& web_event) override; |
| void ForwardWheelEvent(const blink::WebMouseWheelEvent& web_event) override; |
| void GestureBegin(blink::WebGestureEvent begin_event, |
| bool is_synthetically_injected) override; |
| void GestureUpdate(blink::WebGestureEvent update_event) override; |
| void GestureEnd(blink::WebGestureEvent end_event) override; |
| void SmartMagnify(const blink::WebGestureEvent& smart_magnify_event) override; |
| |
| // mojom::RenderWidgetHostNSViewClient implementation. |
| void SyncIsWidgetForMainFrame( |
| SyncIsWidgetForMainFrameCallback callback) override; |
| bool SyncIsWidgetForMainFrame(bool* is_for_main_frame) override; |
| void RequestShutdown() override; |
| void OnFirstResponderChanged(bool is_first_responder) override; |
| void OnWindowIsKeyChanged(bool is_key) override; |
| void OnBoundsInWindowChanged(const gfx::Rect& view_bounds_in_window_dip, |
| bool attached_to_window) override; |
| void OnWindowFrameInScreenChanged( |
| const gfx::Rect& window_frame_in_screen_dip) override; |
| void OnDisplayChanged(const display::Display& display) override; |
| void BeginKeyboardEvent() override; |
| void EndKeyboardEvent() override; |
| |
| void ForwardKeyboardEvent(std::unique_ptr<InputEvent> event, |
| bool skip_in_browser) override; |
| void ForwardKeyboardEventWithCommands( |
| std::unique_ptr<InputEvent> event, |
| bool skip_in_browser, |
| const std::vector<EditCommand>& commands) override; |
| void RouteOrProcessMouseEvent(std::unique_ptr<InputEvent> event) override; |
| void RouteOrProcessTouchEvent(std::unique_ptr<InputEvent> event) override; |
| void RouteOrProcessWheelEvent(std::unique_ptr<InputEvent> event) override; |
| void ForwardMouseEvent(std::unique_ptr<InputEvent> event) override; |
| void ForwardWheelEvent(std::unique_ptr<InputEvent> event) override; |
| void GestureBegin(std::unique_ptr<InputEvent> event, |
| bool is_synthetically_injected) override; |
| void GestureUpdate(std::unique_ptr<InputEvent> event) override; |
| void GestureEnd(std::unique_ptr<InputEvent> event) override; |
| void SmartMagnify(std::unique_ptr<InputEvent> event) override; |
| void ImeSetComposition(const base::string16& text, |
| const std::vector<ui::ImeTextSpan>& ime_text_spans, |
| const gfx::Range& replacement_range, |
| int selection_start, |
| int selection_end) override; |
| void ImeCommitText(const base::string16& text, |
| const gfx::Range& replacement_range) override; |
| void ImeFinishComposingText() override; |
| void ImeCancelCompositionFromCocoa() override; |
| void LookUpDictionaryOverlayAtPoint(const gfx::PointF& root_point) override; |
| void LookUpDictionaryOverlayFromRange(const gfx::Range& range) override; |
| void SyncGetCharacterIndexAtPoint( |
| const gfx::PointF& root_point, |
| SyncGetCharacterIndexAtPointCallback callback) override; |
| bool SyncGetCharacterIndexAtPoint(const gfx::PointF& root_point, |
| uint32_t* index) override; |
| void SyncGetFirstRectForRange( |
| const gfx::Range& requested_range, |
| const gfx::Rect& rect, |
| const gfx::Range& actual_range, |
| SyncGetFirstRectForRangeCallback callback) override; |
| bool SyncGetFirstRectForRange(const gfx::Range& requested_range, |
| const gfx::Rect& rect, |
| const gfx::Range& actual_range, |
| gfx::Rect* out_rect, |
| gfx::Range* out_actual_range, |
| bool* out_success) override; |
| void ExecuteEditCommand(const std::string& command) override; |
| void Undo() override; |
| void Redo() override; |
| void Cut() override; |
| void Copy() override; |
| void CopyToFindPboard() override; |
| void Paste() override; |
| void PasteAndMatchStyle() override; |
| void SelectAll() override; |
| void StartSpeaking() override; |
| void StopSpeaking() override; |
| bool SyncIsSpeaking(bool* is_speaking) override; |
| void SyncIsSpeaking(SyncIsSpeakingCallback callback) override; |
| void SyncGetRootAccessibilityElement( |
| SyncGetRootAccessibilityElementCallback callback) override; |
| void SetRemoteAccessibilityWindowToken( |
| const std::vector<uint8_t>& window_token) override; |
| |
| // BrowserCompositorMacClient implementation. |
| SkColor BrowserCompositorMacGetGutterColor() const override; |
| void BrowserCompositorMacOnBeginFrame(base::TimeTicks frame_time) override; |
| void OnFrameTokenChanged(uint32_t frame_token) override; |
| void DestroyCompositorForShutdown() override; |
| bool OnBrowserCompositorSurfaceIdChanged() override; |
| std::vector<viz::SurfaceId> CollectSurfaceIdsForEviction() override; |
| |
| // AcceleratedWidgetMacNSView implementation. |
| void AcceleratedWidgetCALayerParamsUpdated() override; |
| |
| // ui::AccessibilityFocusOverrider::Client: |
| id GetAccessibilityFocusedUIElement() override; |
| |
| void SetShowingContextMenu(bool showing) override; |
| |
| // Helper method to obtain ui::TextInputType for the active widget from the |
| // TextInputManager. |
| ui::TextInputType GetTextInputType(); |
| |
| // Helper method to obtain the currently active widget from TextInputManager. |
| // An active widget is a RenderWidget which is currently focused and has a |
| // |TextInputState.type| which is not ui::TEXT_INPUT_TYPE_NONE. |
| RenderWidgetHostImpl* GetActiveWidget(); |
| |
| // Returns the composition range information for the active RenderWidgetHost |
| // (accepting IME and keyboard input). |
| const TextInputManager::CompositionRangeInfo* GetCompositionRangeInfo(); |
| |
| // Returns the TextSelection information for the active widget. If |
| // |is_guest_view_hack_| is true, then it will return the TextSelection |
| // information for this RenderWidgetHostViewMac (which is serving as a |
| // platform view for a guest). |
| const TextInputManager::TextSelection* GetTextSelection(); |
| |
| // Get the focused view that should be used for retrieving the text selection. |
| RenderWidgetHostViewBase* GetFocusedViewForTextSelection(); |
| |
| // Returns the RenderWidgetHostDelegate corresponding to the currently focused |
| // RenderWidgetHost. It is different from |render_widget_host_->delegate()| |
| // when there are focused inner WebContentses on the page. Also, this method |
| // can return nullptr; for instance when |render_widget_host_| becomes nullptr |
| // in the destruction path of the WebContentsImpl. |
| RenderWidgetHostDelegate* GetFocusedRenderWidgetHostDelegate(); |
| |
| // Returns the RenderWidgetHostImpl to which Ime messages from the NSView |
| // should be targeted. This exists to preserve historical behavior, and may |
| // not be the desired behavior. |
| // https://crbug.com/831843 |
| RenderWidgetHostImpl* GetWidgetForIme(); |
| |
| // When inside a block of handling a keyboard event, returns the |
| // RenderWidgetHostImpl to which all keyboard and Ime messages from the NSView |
| // should be fowarded. This exists to preserve historical behavior, and may |
| // not be the desired behavior. |
| // https://crbug.com/831843 |
| RenderWidgetHostImpl* GetWidgetForKeyboardEvent(); |
| |
| // Migrate the NSView for this RenderWidgetHostView to be in the process |
| // hosted by |bridge_factory_host|, and make it a child view of the NSView |
| // referred to by |parent_ns_view_id|. |
| void MigrateNSViewBridge(NSViewBridgeFactoryHost* bridge_factory_host, |
| uint64_t parent_ns_view_id); |
| |
| protected: |
| // This class is to be deleted through the Destroy method. |
| ~RenderWidgetHostViewMac() override; |
| |
| private: |
| friend class RenderWidgetHostViewMacTest; |
| friend class MockPointerLockRenderWidgetHostView; |
| FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewMacTest, GetPageTextForSpeech); |
| |
| // Allocate a new FrameSinkId if this object is the platform view of a |
| // RenderWidgetHostViewGuest. This FrameSinkId will not be actually used in |
| // any useful way. It's only created because BrowserCompositorMac always |
| // expects to have a FrameSinkId. FrameSinkIds generated by this method do not |
| // collide with FrameSinkIds used by RenderWidgetHostImpls. |
| static viz::FrameSinkId AllocateFrameSinkIdForGuestViewHack(); |
| |
| MouseWheelPhaseHandler* GetMouseWheelPhaseHandler() override; |
| |
| // Shuts down the render_widget_host_. This is a separate function so we can |
| // invoke it from the message loop. |
| void ShutdownHost(); |
| |
| // Send updated vsync parameters to the top level display. |
| void UpdateDisplayVSyncParameters(); |
| |
| // Adds/Removes frame observer based on state. |
| void UpdateNeedsBeginFramesInternal(); |
| |
| void SendSyntheticWheelEventWithPhaseEnded( |
| blink::WebMouseWheelEvent wheel_event, |
| bool should_route_event); |
| |
| void OnDidUpdateVisualPropertiesComplete( |
| const cc::RenderFrameMetadata& metadata); |
| |
| void OnGotStringForDictionaryOverlay( |
| int32_t targetWidgetProcessId, |
| int32_t targetWidgetRoutingId, |
| const mac::AttributedStringCoder::EncodedString& encodedString, |
| gfx::Point baselinePoint); |
| |
| // RenderWidgetHostViewBase: |
| void UpdateBackgroundColor() override; |
| bool HasFallbackSurface() const override; |
| |
| // Gets a textual view of the page's contents, and passes it to the callback |
| // provided. |
| using SpeechCallback = base::OnceCallback<void(const base::string16&)>; |
| void GetPageTextForSpeech(SpeechCallback callback); |
| |
| // Interface through which the NSView is to be manipulated. This points either |
| // to |ns_view_bridge_local_| or to (to-be-added) |ns_view_bridge_remote_|. |
| mojom::RenderWidgetHostNSViewBridge* ns_view_bridge_ = nullptr; |
| |
| // If |ns_view_bridge_| is hosted in this process, then this will be non-null, |
| // and may be used to query the actual RenderWidgetHostViewCocoa that is being |
| // used for |this|. Any functionality that uses |new_view_bridge_local_| will |
| // not work when the RenderWidgetHostViewCocoa is hosted in an app process. |
| std::unique_ptr<RenderWidgetHostNSViewBridgeLocal> ns_view_bridge_local_; |
| |
| // If the NSView is hosted in a remote process and accessed via mojo then |
| // - |ns_view_bridge_| will point to |ns_view_bridge_remote_| |
| // - |ns_view_client_binding_| is the binding provided to the bridge. |
| mojom::RenderWidgetHostNSViewBridgeAssociatedPtr ns_view_bridge_remote_; |
| mojo::AssociatedBinding<mojom::RenderWidgetHostNSViewClient> |
| ns_view_client_binding_; |
| |
| // State tracked by Show/Hide/IsShowing. |
| bool is_visible_ = false; |
| |
| // Set to true if |this| has ever been displayed via a parent ui::Layer (in |
| // which case its NSView will only ever be used for input, not display). |
| bool display_only_using_parent_ui_layer_ = false; |
| |
| // The bounds of the view in its NSWindow's coordinate system (with origin |
| // in the upper-left). |
| gfx::Rect view_bounds_in_window_dip_; |
| |
| // The frame of the window in the global display::Screen coordinate system |
| // (where the origin is the upper-left corner of Screen::GetPrimaryDisplay). |
| gfx::Rect window_frame_in_screen_dip_; |
| |
| // Cached copy of the display information pushed to us from the NSView. |
| display::Display display_; |
| |
| // Whether or not the NSView's NSWindow is the key window. |
| bool is_window_key_ = false; |
| |
| // Whether or not the NSView is first responder. |
| bool is_first_responder_ = false; |
| |
| // Indicates if the page is loading. |
| bool is_loading_; |
| |
| // True when this view acts as a platform view hack for a |
| // RenderWidgetHostViewGuest. |
| bool is_guest_view_hack_; |
| |
| // Our parent host view, if this is a popup. NULL otherwise. |
| RenderWidgetHostViewMac* popup_parent_host_view_; |
| |
| // Our child popup host. NULL if we do not have a child popup. |
| RenderWidgetHostViewMac* popup_child_host_view_; |
| |
| // Display link for getting vsync info. |
| scoped_refptr<ui::DisplayLinkMac> display_link_; |
| |
| // Whether a request for begin frames has been issued. |
| bool needs_begin_frames_; |
| |
| // Whether or not the background is opaque as determined by calls to |
| // SetBackgroundColor. The default value is opaque. |
| bool background_is_opaque_ = true; |
| |
| // The color of the background CALayer, stored as a SkColor for efficient |
| // comparison. Initially transparent so that the embedding NSView shows |
| // through. |
| SkColor background_layer_color_ = SK_ColorTRANSPARENT; |
| |
| // The background color of the last frame that was swapped. This is not |
| // applied until the swap completes (see comments in |
| // AcceleratedWidgetCALayerParamsUpdated). |
| SkColor last_frame_root_background_color_ = SK_ColorTRANSPARENT; |
| |
| std::unique_ptr<CursorManager> cursor_manager_; |
| |
| // Used to track active password input sessions. |
| std::unique_ptr<ui::ScopedPasswordInputEnabler> password_input_enabler_; |
| |
| // Provides gesture synthesis given a stream of touch events and touch event |
| // acks. This is for generating gesture events from injected touch events. |
| ui::FilteredGestureProvider gesture_provider_; |
| |
| // Used to ensure that a consistent RenderWidgetHost is targeted throughout |
| // the duration of a keyboard event. |
| bool in_keyboard_event_ = false; |
| int32_t keyboard_event_widget_process_id_ = 0; |
| int32_t keyboard_event_widget_routing_id_ = 0; |
| |
| // When a gesture starts, the system does not inform the view of which type |
| // of gesture is happening (magnify, rotate, etc), rather, it just informs |
| // the view that some as-yet-undefined gesture is starting. Capture the |
| // information about the gesture's beginning event here. It will be used to |
| // create a specific gesture begin event later. |
| std::unique_ptr<blink::WebGestureEvent> gesture_begin_event_; |
| |
| // This is set if a GesturePinchBegin event has been sent in the lifetime of |
| // |gesture_begin_event__|. If set, a GesturePinchEnd will be sent when the |
| // gesture ends. |
| bool gesture_begin_pinch_sent_ = false; |
| |
| // To avoid accidental pinches, require that a certain zoom threshold be |
| // reached before forwarding it to the browser. Use |pinch_unused_amount_| to |
| // hold this value. If the user reaches this value, don't re-require the |
| // threshold be reached until the page has been zoomed back to page scale of |
| // one. |
| bool pinch_has_reached_zoom_threshold_ = false; |
| float pinch_unused_amount_ = 1.f; |
| |
| // Tracks whether keyboard lock is active. |
| bool is_keyboard_locked_ = false; |
| |
| // While the mouse is locked, the cursor is hidden from the user. Mouse events |
| // are still generated. However, the position they report is the last known |
| // mouse position just as mouse lock was entered; the movement they report |
| // indicates what the change in position of the mouse would be had it not been |
| // locked. |
| bool mouse_locked_ = false; |
| |
| // Latest capture sequence number which is incremented when the caller |
| // requests surfaces be synchronized via |
| // EnsureSurfaceSynchronizedForWebTest(). |
| uint32_t latest_capture_sequence_number_ = 0u; |
| |
| // Remote accessibility objects corresponding to the NSWindow that this is |
| // displayed to the user in. |
| base::scoped_nsobject<NSAccessibilityRemoteUIElement> |
| remote_window_accessible_; |
| |
| // Used to force the NSApplication's focused accessibility element to be the |
| // content::BrowserAccessibilityCocoa accessibility tree when the NSView for |
| // this is focused. |
| ui::AccessibilityFocusOverrider accessibility_focus_overrider_; |
| |
| // Factory used to safely scope delayed calls to ShutdownHost(). |
| base::WeakPtrFactory<RenderWidgetHostViewMac> weak_factory_; |
| |
| DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewMac); |
| }; |
| |
| // RenderWidgetHostViewCocoa is not exported outside of content. This helper |
| // method provides the tests with the class object so that they can override the |
| // methods according to the tests' requirements. |
| CONTENT_EXPORT Class GetRenderWidgetHostViewCocoaClassForTesting(); |
| |
| } // namespace content |
| |
| #endif // CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_MAC_H_ |