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.
5 #ifndef CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_AURA_H_
6 #define CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_AURA_H_
13 #include "base/callback.h"
14 #include "base/gtest_prod_util.h"
15 #include "base/memory/linked_ptr.h"
16 #include "base/memory/ref_counted.h"
17 #include "base/memory/scoped_ptr.h"
18 #include "base/memory/weak_ptr.h"
19 #include "content/browser/accessibility/browser_accessibility_manager.h"
20 #include "content/browser/compositor/delegated_frame_host.h"
21 #include "content/browser/compositor/image_transport_factory.h"
22 #include "content/browser/compositor/owned_mailbox.h"
23 #include "content/browser/renderer_host/render_widget_host_view_base.h"
24 #include "content/common/content_export.h"
25 #include "content/common/cursors/webcursor.h"
26 #include "third_party/skia/include/core/SkRegion.h"
27 #include "ui/aura/client/cursor_client_observer.h"
28 #include "ui/aura/client/focus_change_observer.h"
29 #include "ui/aura/window_delegate.h"
30 #include "ui/aura/window_tree_host_observer.h"
31 #include "ui/base/ime/text_input_client.h"
32 #include "ui/gfx/display_observer.h"
33 #include "ui/gfx/insets.h"
34 #include "ui/gfx/rect.h"
35 #include "ui/wm/public/activation_change_observer.h"
36 #include "ui/wm/public/activation_delegate.h"
41 class ScopedTooltipDisabler;
46 class CopyOutputRequest;
47 class CopyOutputResult;
48 class DelegatedFrameData;
69 class LegacyRenderWidgetHostHWND;
72 class OverscrollController;
73 class RenderFrameHostImpl;
74 class RenderWidgetHostImpl;
75 class RenderWidgetHostView;
77 // RenderWidgetHostView class hierarchy described in render_widget_host_view.h.
78 class CONTENT_EXPORT RenderWidgetHostViewAura
79 : public RenderWidgetHostViewBase,
80 public DelegatedFrameHostClient,
81 public ui::TextInputClient,
82 public gfx::DisplayObserver,
83 public aura::WindowTreeHostObserver,
84 public aura::WindowDelegate,
85 public aura::client::ActivationDelegate,
86 public aura::client::ActivationChangeObserver,
87 public aura::client::FocusChangeObserver,
88 public aura::client::CursorClientObserver,
89 public base::SupportsWeakPtr<RenderWidgetHostViewAura> {
91 // Displays and controls touch editing elements such as selection handles.
92 class TouchEditingClient {
94 TouchEditingClient() {}
96 // Tells the client to start showing touch editing handles.
97 virtual void StartTouchEditing() = 0;
99 // Notifies the client that touch editing is no longer needed. |quick|
100 // determines whether the handles should fade out quickly or slowly.
101 virtual void EndTouchEditing(bool quick) = 0;
103 // Notifies the client that the selection bounds need to be updated.
104 virtual void OnSelectionOrCursorChanged(const gfx::Rect& anchor,
105 const gfx::Rect& focus) = 0;
107 // Notifies the client that the current text input type as changed.
108 virtual void OnTextInputTypeChanged(ui::TextInputType type) = 0;
110 // Notifies the client that an input event is about to be sent to the
111 // renderer. Returns true if the client wants to stop event propagation.
112 virtual bool HandleInputEvent(const ui::Event* event) = 0;
114 // Notifies the client that a gesture event ack was received.
115 virtual void GestureEventAck(int gesture_event_type) = 0;
117 // Notifies the client that the fling has ended, so it can activate touch
118 // editing if needed.
119 virtual void DidStopFlinging() = 0;
121 // This is called when the view is destroyed, so that the client can
122 // perform any necessary clean-up.
123 virtual void OnViewDestroyed() = 0;
126 virtual ~TouchEditingClient() {}
129 void set_touch_editing_client(TouchEditingClient* client) {
130 touch_editing_client_ = client;
133 explicit RenderWidgetHostViewAura(RenderWidgetHost* host);
135 // RenderWidgetHostView implementation.
136 virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
137 virtual void InitAsChild(gfx::NativeView parent_view) OVERRIDE;
138 virtual RenderWidgetHost* GetRenderWidgetHost() const OVERRIDE;
139 virtual void SetSize(const gfx::Size& size) OVERRIDE;
140 virtual void SetBounds(const gfx::Rect& rect) OVERRIDE;
141 virtual gfx::Vector2dF GetLastScrollOffset() const OVERRIDE;
142 virtual gfx::NativeView GetNativeView() const OVERRIDE;
143 virtual gfx::NativeViewId GetNativeViewId() const OVERRIDE;
144 virtual gfx::NativeViewAccessible GetNativeViewAccessible() OVERRIDE;
145 virtual ui::TextInputClient* GetTextInputClient() OVERRIDE;
146 virtual bool HasFocus() const OVERRIDE;
147 virtual bool IsSurfaceAvailableForCopy() const OVERRIDE;
148 virtual void Show() OVERRIDE;
149 virtual void Hide() OVERRIDE;
150 virtual bool IsShowing() OVERRIDE;
151 virtual gfx::Rect GetViewBounds() const OVERRIDE;
152 virtual void SetBackgroundOpaque(bool opaque) OVERRIDE;
153 virtual gfx::Size GetVisibleViewportSize() const OVERRIDE;
154 virtual void SetInsets(const gfx::Insets& insets) OVERRIDE;
156 // Overridden from RenderWidgetHostViewBase:
157 virtual void InitAsPopup(RenderWidgetHostView* parent_host_view,
158 const gfx::Rect& pos) OVERRIDE;
159 virtual void InitAsFullscreen(
160 RenderWidgetHostView* reference_host_view) OVERRIDE;
161 virtual void WasShown() OVERRIDE;
162 virtual void WasHidden() OVERRIDE;
163 virtual void MovePluginWindows(
164 const std::vector<WebPluginGeometry>& moves) OVERRIDE;
165 virtual void Focus() OVERRIDE;
166 virtual void Blur() OVERRIDE;
167 virtual void UpdateCursor(const WebCursor& cursor) OVERRIDE;
168 virtual void SetIsLoading(bool is_loading) OVERRIDE;
169 virtual void TextInputTypeChanged(ui::TextInputType type,
170 ui::TextInputMode input_mode,
171 bool can_compose_inline) OVERRIDE;
172 virtual void ImeCancelComposition() OVERRIDE;
173 virtual void ImeCompositionRangeChanged(
174 const gfx::Range& range,
175 const std::vector<gfx::Rect>& character_bounds) OVERRIDE;
176 virtual void RenderProcessGone(base::TerminationStatus status,
177 int error_code) OVERRIDE;
178 virtual void Destroy() OVERRIDE;
179 virtual void SetTooltipText(const base::string16& tooltip_text) OVERRIDE;
180 virtual void SelectionChanged(const base::string16& text,
182 const gfx::Range& range) OVERRIDE;
183 virtual gfx::Size GetRequestedRendererSize() const OVERRIDE;
184 virtual void SelectionBoundsChanged(
185 const ViewHostMsg_SelectionBounds_Params& params) OVERRIDE;
186 virtual void CopyFromCompositingSurface(
187 const gfx::Rect& src_subrect,
188 const gfx::Size& dst_size,
189 CopyFromCompositingSurfaceCallback& callback,
190 const SkColorType color_type) OVERRIDE;
191 virtual void CopyFromCompositingSurfaceToVideoFrame(
192 const gfx::Rect& src_subrect,
193 const scoped_refptr<media::VideoFrame>& target,
194 const base::Callback<void(bool)>& callback) OVERRIDE;
195 virtual bool CanCopyToVideoFrame() const OVERRIDE;
196 virtual bool CanSubscribeFrame() const OVERRIDE;
197 virtual void BeginFrameSubscription(
198 scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) OVERRIDE;
199 virtual void EndFrameSubscription() OVERRIDE;
200 virtual void AcceleratedSurfaceInitialized(int host_id,
201 int route_id) OVERRIDE;
202 virtual void AcceleratedSurfaceBuffersSwapped(
203 const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params_in_pixel,
204 int gpu_host_id) OVERRIDE;
205 virtual void AcceleratedSurfacePostSubBuffer(
206 const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params_in_pixel,
207 int gpu_host_id) OVERRIDE;
208 virtual void AcceleratedSurfaceSuspend() OVERRIDE;
209 virtual void AcceleratedSurfaceRelease() OVERRIDE;
210 virtual bool HasAcceleratedSurface(const gfx::Size& desired_size) OVERRIDE;
211 virtual void GetScreenInfo(blink::WebScreenInfo* results) OVERRIDE;
212 virtual gfx::Rect GetBoundsInRootWindow() OVERRIDE;
213 virtual void WheelEventAck(const blink::WebMouseWheelEvent& event,
214 InputEventAckState ack_result) OVERRIDE;
215 virtual void GestureEventAck(const blink::WebGestureEvent& event,
216 InputEventAckState ack_result) OVERRIDE;
217 virtual void ProcessAckedTouchEvent(
218 const TouchEventWithLatencyInfo& touch,
219 InputEventAckState ack_result) OVERRIDE;
220 virtual scoped_ptr<SyntheticGestureTarget> CreateSyntheticGestureTarget()
222 virtual InputEventAckState FilterInputEvent(
223 const blink::WebInputEvent& input_event) OVERRIDE;
224 virtual gfx::GLSurfaceHandle GetCompositingSurface() OVERRIDE;
225 virtual BrowserAccessibilityManager* CreateBrowserAccessibilityManager(
226 BrowserAccessibilityDelegate* delegate) OVERRIDE;
227 virtual gfx::AcceleratedWidget AccessibilityGetAcceleratedWidget() OVERRIDE;
228 virtual gfx::NativeViewAccessible AccessibilityGetNativeViewAccessible()
230 virtual void ShowDisambiguationPopup(const gfx::Rect& rect_pixels,
231 const SkBitmap& zoomed_bitmap) OVERRIDE;
232 virtual bool LockMouse() OVERRIDE;
233 virtual void UnlockMouse() OVERRIDE;
234 virtual void OnSwapCompositorFrame(
235 uint32 output_surface_id,
236 scoped_ptr<cc::CompositorFrame> frame) OVERRIDE;
237 virtual void DidStopFlinging() OVERRIDE;
240 virtual void SetParentNativeViewAccessible(
241 gfx::NativeViewAccessible accessible_parent) OVERRIDE;
242 virtual gfx::NativeViewId GetParentForWindowlessPlugin() const OVERRIDE;
245 // Overridden from ui::TextInputClient:
246 virtual void SetCompositionText(
247 const ui::CompositionText& composition) OVERRIDE;
248 virtual void ConfirmCompositionText() OVERRIDE;
249 virtual void ClearCompositionText() OVERRIDE;
250 virtual void InsertText(const base::string16& text) OVERRIDE;
251 virtual void InsertChar(base::char16 ch, int flags) OVERRIDE;
252 virtual gfx::NativeWindow GetAttachedWindow() const OVERRIDE;
253 virtual ui::TextInputType GetTextInputType() const OVERRIDE;
254 virtual ui::TextInputMode GetTextInputMode() const OVERRIDE;
255 virtual bool CanComposeInline() const OVERRIDE;
256 virtual gfx::Rect GetCaretBounds() const OVERRIDE;
257 virtual bool GetCompositionCharacterBounds(uint32 index,
258 gfx::Rect* rect) const OVERRIDE;
259 virtual bool HasCompositionText() const OVERRIDE;
260 virtual bool GetTextRange(gfx::Range* range) const OVERRIDE;
261 virtual bool GetCompositionTextRange(gfx::Range* range) const OVERRIDE;
262 virtual bool GetSelectionRange(gfx::Range* range) const OVERRIDE;
263 virtual bool SetSelectionRange(const gfx::Range& range) OVERRIDE;
264 virtual bool DeleteRange(const gfx::Range& range) OVERRIDE;
265 virtual bool GetTextFromRange(const gfx::Range& range,
266 base::string16* text) const OVERRIDE;
267 virtual void OnInputMethodChanged() OVERRIDE;
268 virtual bool ChangeTextDirectionAndLayoutAlignment(
269 base::i18n::TextDirection direction) OVERRIDE;
270 virtual void ExtendSelectionAndDelete(size_t before, size_t after) OVERRIDE;
271 virtual void EnsureCaretInRect(const gfx::Rect& rect) OVERRIDE;
272 virtual void OnCandidateWindowShown() OVERRIDE;
273 virtual void OnCandidateWindowUpdated() OVERRIDE;
274 virtual void OnCandidateWindowHidden() OVERRIDE;
275 virtual bool IsEditingCommandEnabled(int command_id) OVERRIDE;
276 virtual void ExecuteEditingCommand(int command_id) OVERRIDE;
278 // Overridden from gfx::DisplayObserver:
279 virtual void OnDisplayAdded(const gfx::Display& new_display) OVERRIDE;
280 virtual void OnDisplayRemoved(const gfx::Display& old_display) OVERRIDE;
281 virtual void OnDisplayMetricsChanged(const gfx::Display& display,
282 uint32_t metrics) OVERRIDE;
284 // Overridden from aura::WindowDelegate:
285 virtual gfx::Size GetMinimumSize() const OVERRIDE;
286 virtual gfx::Size GetMaximumSize() const OVERRIDE;
287 virtual void OnBoundsChanged(const gfx::Rect& old_bounds,
288 const gfx::Rect& new_bounds) OVERRIDE;
289 virtual gfx::NativeCursor GetCursor(const gfx::Point& point) OVERRIDE;
290 virtual int GetNonClientComponent(const gfx::Point& point) const OVERRIDE;
291 virtual bool ShouldDescendIntoChildForEventHandling(
293 const gfx::Point& location) OVERRIDE;
294 virtual bool CanFocus() OVERRIDE;
295 virtual void OnCaptureLost() OVERRIDE;
296 virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
297 virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE;
298 virtual void OnWindowDestroying(aura::Window* window) OVERRIDE;
299 virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE;
300 virtual void OnWindowTargetVisibilityChanged(bool visible) OVERRIDE;
301 virtual bool HasHitTestMask() const OVERRIDE;
302 virtual void GetHitTestMask(gfx::Path* mask) const OVERRIDE;
304 // Overridden from ui::EventHandler:
305 virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
306 virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
307 virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
308 virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
309 virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
311 // Overridden from aura::client::ActivationDelegate:
312 virtual bool ShouldActivate() const OVERRIDE;
314 // Overridden from aura::client::ActivationChangeObserver:
315 virtual void OnWindowActivated(aura::Window* gained_activation,
316 aura::Window* lost_activation) OVERRIDE;
318 // Overridden from aura::client::CursorClientObserver:
319 virtual void OnCursorVisibilityChanged(bool is_visible) OVERRIDE;
321 // Overridden from aura::client::FocusChangeObserver:
322 virtual void OnWindowFocused(aura::Window* gained_focus,
323 aura::Window* lost_focus) OVERRIDE;
325 // Overridden from aura::WindowTreeHostObserver:
326 virtual void OnHostMoved(const aura::WindowTreeHost* host,
327 const gfx::Point& new_origin) OVERRIDE;
329 void OnTextInputStateChanged(const ViewHostMsg_TextInputState_Params& params);
332 // Sets the cutout rects from constrained windows. These are rectangles that
333 // windowed NPAPI plugins shouldn't paint in. Overwrites any previous cutout
335 void UpdateConstrainedWindowRects(const std::vector<gfx::Rect>& rects);
337 // Updates the cursor clip region. Used for mouse locking.
338 void UpdateMouseLockRegion();
340 // Notification that the LegacyRenderWidgetHostHWND was destroyed.
341 void OnLegacyWindowDestroyed();
344 void DisambiguationPopupRendered(bool success, const SkBitmap& result);
346 void HideDisambiguationPopup();
348 void ProcessDisambiguationGesture(ui::GestureEvent* event);
350 void ProcessDisambiguationMouse(ui::MouseEvent* event);
352 // Method to indicate if this instance is shutting down or closing.
353 // TODO(shrikant): Discuss around to see if it makes sense to add this method
354 // as part of RenderWidgetHostView.
355 bool IsClosing() const { return in_shutdown_; }
357 // Sets whether the overscroll controller should be enabled for this page.
358 void SetOverscrollControllerEnabled(bool enabled);
360 void SnapToPhysicalPixelBoundary();
362 OverscrollController* overscroll_controller() const {
363 return overscroll_controller_.get();
367 virtual ~RenderWidgetHostViewAura();
369 // Exposed for tests.
370 aura::Window* window() { return window_; }
371 virtual SkColorType PreferredReadbackFormat() OVERRIDE;
372 virtual DelegatedFrameHost* GetDelegatedFrameHost() const OVERRIDE;
375 FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest, SetCompositionText);
376 FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest, TouchEventState);
377 FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest,
378 TouchEventPositionsArentRounded);
379 FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest, TouchEventSyncAsync);
380 FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest, SwapNotifiesWindow);
381 FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest,
382 SkippedDelegatedFrames);
383 FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest, OutputSurfaceIdChange);
384 FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest,
385 DiscardDelegatedFrames);
386 FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest,
387 DiscardDelegatedFramesWithLocking);
388 FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest, SoftwareDPIChange);
389 FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest,
390 UpdateCursorIfOverSelf);
391 FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraCopyRequestTest,
392 DestroyedAfterCopyRequest);
393 FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest,
394 VisibleViewportTest);
395 FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest,
396 OverscrollResetsOnBlur);
397 FRIEND_TEST_ALL_PREFIXES(WebContentsViewAuraTest,
398 WebContentsViewReparent);
400 class WindowObserver;
401 friend class WindowObserver;
403 void UpdateCursorIfOverSelf();
405 // Tracks whether SnapToPhysicalPixelBoundary() has been called.
406 bool has_snapped_to_boundary() { return has_snapped_to_boundary_; }
407 void ResetHasSnappedToBoundary() { has_snapped_to_boundary_ = false; }
409 // Set the bounds of the window and handle size changes. Assumes the caller
410 // has already adjusted the origin of |rect| to conform to whatever coordinate
411 // space is required by the aura::Window.
412 void InternalSetBounds(const gfx::Rect& rect);
415 bool UsesNativeWindowFrame() const;
418 ui::InputMethod* GetInputMethod() const;
420 // Returns whether the widget needs an input grab to work properly.
421 bool NeedsInputGrab();
423 // Confirm existing composition text in the webpage and ask the input method
424 // to cancel its ongoing composition session.
425 void FinishImeCompositionSession();
427 // This method computes movementX/Y and keeps track of mouse location for
428 // mouse lock on all mouse move events.
429 void ModifyEventMovementAndCoords(blink::WebMouseEvent* event);
431 // Sends an IPC to the renderer process to communicate whether or not
432 // the mouse cursor is visible anywhere on the screen.
433 void NotifyRendererOfCursorVisibilityState(bool is_visible);
435 // If |clip| is non-empty and and doesn't contain |rect| or |clip| is empty
436 // SchedulePaint() is invoked for |rect|.
437 void SchedulePaintIfNotInClip(const gfx::Rect& rect, const gfx::Rect& clip);
439 // Helper method to determine if, in mouse locked mode, the cursor should be
441 bool ShouldMoveToCenter();
443 // Called after |window_| is parented to a WindowEventDispatcher.
444 void AddedToRootWindow();
446 // Called prior to removing |window_| from a WindowEventDispatcher.
447 void RemovingFromRootWindow();
449 // DelegatedFrameHostClient implementation.
450 virtual ui::Compositor* GetCompositor() const OVERRIDE;
451 virtual ui::Layer* GetLayer() OVERRIDE;
452 virtual RenderWidgetHostImpl* GetHost() OVERRIDE;
453 virtual bool IsVisible() OVERRIDE;
454 virtual scoped_ptr<ResizeLock> CreateResizeLock(
455 bool defer_compositor_lock) OVERRIDE;
456 virtual gfx::Size DesiredFrameSize() OVERRIDE;
457 virtual float CurrentDeviceScaleFactor() OVERRIDE;
458 virtual gfx::Size ConvertViewSizeToPixel(const gfx::Size& size) OVERRIDE;
460 // Detaches |this| from the input method object.
461 void DetachFromInputMethod();
463 // Before calling RenderWidgetHost::ForwardKeyboardEvent(), this method
464 // calls our keybindings handler against the event and send matched
465 // edit commands to renderer instead.
466 void ForwardKeyboardEvent(const NativeWebKeyboardEvent& event);
468 // Dismisses a Web Popup on a mouse or touch press outside the popup and its
470 void ApplyEventFilterForPopupExit(ui::LocatedEvent* event);
472 // Converts |rect| from window coordinate to screen coordinate.
473 gfx::Rect ConvertRectToScreen(const gfx::Rect& rect) const;
475 // Converts |rect| from screen coordinate to window coordinate.
476 gfx::Rect ConvertRectFromScreen(const gfx::Rect& rect) const;
478 // Helper function to set keyboard focus to the main window.
479 void SetKeyboardFocus();
481 RenderFrameHostImpl* GetFocusedFrame();
484 RenderWidgetHostImpl* host_;
486 aura::Window* window_;
488 scoped_ptr<DelegatedFrameHost> delegated_frame_host_;
490 scoped_ptr<WindowObserver> window_observer_;
492 // Are we in the process of closing? Tracked so fullscreen views can avoid
493 // sending a second shutdown request to the host when they lose the focus
494 // after requesting shutdown for another reason (e.g. Escape key).
497 // True if in the process of handling a window bounds changed notification.
498 bool in_bounds_changed_;
500 // Is this a fullscreen view?
503 // Our parent host view, if this is a popup. NULL otherwise.
504 RenderWidgetHostViewAura* popup_parent_host_view_;
506 // Our child popup host. NULL if we do not have a child popup.
507 RenderWidgetHostViewAura* popup_child_host_view_;
509 class EventFilterForPopupExit;
510 friend class EventFilterForPopupExit;
511 scoped_ptr<ui::EventHandler> event_filter_for_popup_exit_;
513 // True when content is being loaded. Used to show an hourglass cursor.
516 // The cursor for the page. This is passed up from the renderer.
517 WebCursor current_cursor_;
519 // The touch-event. Its touch-points are updated as necessary. A new
520 // touch-point is added from an ET_TOUCH_PRESSED event, and a touch-point is
521 // removed from the list on an ET_TOUCH_RELEASED event.
522 blink::WebTouchEvent touch_event_;
524 // The current text input type.
525 ui::TextInputType text_input_type_;
526 // The current text input mode corresponding to HTML5 inputmode attribute.
527 ui::TextInputMode text_input_mode_;
528 bool can_compose_inline_;
530 // Rectangles for the selection anchor and focus.
531 gfx::Rect selection_anchor_rect_;
532 gfx::Rect selection_focus_rect_;
534 // The current composition character bounds.
535 std::vector<gfx::Rect> composition_character_bounds_;
537 // Indicates if there is onging composition text.
538 bool has_composition_text_;
540 // Whether return characters should be passed on to the RenderWidgetHostImpl.
541 bool accept_return_character_;
543 // Current tooltip text.
544 base::string16 tooltip_;
546 // The size and scale of the last software compositing frame that was swapped.
547 gfx::Size last_swapped_software_frame_size_;
548 float last_swapped_software_frame_scale_factor_;
550 // If non-NULL we're in OnPaint() and this is the supplied canvas.
551 gfx::Canvas* paint_canvas_;
553 // Used to record the last position of the mouse.
554 // While the mouse is locked, they store the last known position just as mouse
556 // Relative to the upper-left corner of the view.
557 gfx::Point unlocked_mouse_position_;
558 // Relative to the upper-left corner of the screen.
559 gfx::Point unlocked_global_mouse_position_;
560 // Last cursor position relative to screen. Used to compute movementX/Y.
561 gfx::Point global_mouse_position_;
562 // In mouse locked mode, we synthetically move the mouse cursor to the center
563 // of the window when it reaches the window borders to avoid it going outside.
564 // This flag is used to differentiate between these synthetic mouse move
565 // events vs. normal mouse move events.
566 bool synthetic_move_sent_;
568 // Used to track the state of the window we're created from. Only used when
569 // created fullscreen.
570 scoped_ptr<aura::WindowTracker> host_tracker_;
572 // Used to track the last cursor visibility update that was sent to the
573 // renderer via NotifyRendererOfCursorVisibilityState().
574 enum CursorVisibilityState {
579 CursorVisibilityState cursor_visibility_state_in_renderer_;
582 // The list of rectangles from constrained windows over this view. Windowed
583 // NPAPI plugins shouldn't draw over them.
584 std::vector<gfx::Rect> constrained_rects_;
586 typedef std::map<HWND, WebPluginGeometry> PluginWindowMoves;
587 // Contains information about each windowed plugin's clip and cutout rects (
588 // from the renderer). This is needed because when the transient windows
589 // over this view changes, we need this information in order to create a new
590 // region for the HWND.
591 PluginWindowMoves plugin_window_moves_;
593 // The LegacyRenderWidgetHostHWND class provides a dummy HWND which is used
594 // for accessibility, as the container for windowless plugins like
595 // Flash/Silverlight, etc and for legacy drivers for trackpoints/trackpads,
597 // The LegacyRenderWidgetHostHWND instance is created during the first call
598 // to RenderWidgetHostViewAura::InternalSetBounds. The instance is destroyed
599 // when the LegacyRenderWidgetHostHWND hwnd is destroyed.
600 content::LegacyRenderWidgetHostHWND* legacy_render_widget_host_HWND_;
602 // Set to true if the legacy_render_widget_host_HWND_ instance was destroyed
603 // by Windows. This could happen if the browser window was destroyed by
604 // DestroyWindow for e.g. This flag helps ensure that we don't try to create
605 // the LegacyRenderWidgetHostHWND instance again as that would be a futile
607 bool legacy_window_destroyed_;
610 bool has_snapped_to_boundary_;
612 TouchEditingClient* touch_editing_client_;
614 scoped_ptr<OverscrollController> overscroll_controller_;
616 // The last scroll offset of the view.
617 gfx::Vector2dF last_scroll_offset_;
621 std::vector<ui::LatencyInfo> software_latency_info_;
623 scoped_ptr<aura::client::ScopedTooltipDisabler> tooltip_disabler_;
625 base::WeakPtrFactory<RenderWidgetHostViewAura> weak_ptr_factory_;
627 gfx::Rect disambiguation_target_rect_;
629 // The last scroll offset when we start to render the link disambiguation
630 // view, so we can ensure the window hasn't moved between copying from the
631 // compositing surface and showing the disambiguation popup.
632 gfx::Vector2dF disambiguation_scroll_offset_;
634 DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewAura);
637 } // namespace content
639 #endif // CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_AURA_H_