1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
|
// 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_AURA_H_
#define CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_AURA_H_
#include <map>
#include <string>
#include <vector>
#include "base/callback.h"
#include "base/gtest_prod_util.h"
#include "base/memory/linked_ptr.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "cc/layers/delegated_frame_provider.h"
#include "cc/layers/delegated_frame_resource_collection.h"
#include "cc/resources/texture_mailbox.h"
#include "content/browser/accessibility/browser_accessibility_manager.h"
#include "content/browser/aura/image_transport_factory.h"
#include "content/browser/aura/owned_mailbox.h"
#include "content/browser/renderer_host/delegated_frame_evictor.h"
#include "content/browser/renderer_host/render_widget_host_view_base.h"
#include "content/browser/renderer_host/software_frame_manager.h"
#include "content/common/content_export.h"
#include "content/common/gpu/client/gl_helper.h"
#include "third_party/skia/include/core/SkRegion.h"
#include "ui/aura/client/activation_change_observer.h"
#include "ui/aura/client/activation_delegate.h"
#include "ui/aura/client/cursor_client_observer.h"
#include "ui/aura/client/focus_change_observer.h"
#include "ui/aura/root_window_observer.h"
#include "ui/aura/window_delegate.h"
#include "ui/base/ime/text_input_client.h"
#include "ui/compositor/compositor.h"
#include "ui/compositor/compositor_observer.h"
#include "ui/gfx/display_observer.h"
#include "ui/gfx/rect.h"
#include "webkit/common/cursors/webcursor.h"
namespace aura {
class WindowTracker;
}
namespace cc {
class CopyOutputResult;
class DelegatedFrameData;
}
namespace gfx {
class Canvas;
class Display;
}
namespace ui {
class CompositorLock;
class InputMethod;
class Texture;
}
namespace content {
class RenderWidgetHostImpl;
class RenderWidgetHostView;
class ResizeLock;
// RenderWidgetHostView class hierarchy described in render_widget_host_view.h.
class CONTENT_EXPORT RenderWidgetHostViewAura
: public RenderWidgetHostViewBase,
public ui::CompositorObserver,
public ui::TextInputClient,
public gfx::DisplayObserver,
public aura::RootWindowObserver,
public aura::WindowDelegate,
public aura::client::ActivationDelegate,
public aura::client::ActivationChangeObserver,
public aura::client::FocusChangeObserver,
public aura::client::CursorClientObserver,
public ImageTransportFactoryObserver,
public BrowserAccessibilityDelegate,
public SoftwareFrameManagerClient,
public DelegatedFrameEvictorClient,
public base::SupportsWeakPtr<RenderWidgetHostViewAura>,
public cc::DelegatedFrameResourceCollectionClient {
public:
// Used to notify whenever the paint-content of the view changes.
class PaintObserver {
public:
PaintObserver() {}
virtual ~PaintObserver() {}
// This is called when painting of the page is completed.
virtual void OnPaintComplete() = 0;
// This is called when compositor painting of the page is completed.
virtual void OnCompositingComplete() = 0;
// This is called when the contents for compositor painting changes.
virtual void OnUpdateCompositorContent() = 0;
// This is called loading the page has completed.
virtual void OnPageLoadComplete() = 0;
// This is called when the view is destroyed, so that the observer can
// perform any necessary clean-up.
virtual void OnViewDestroyed() = 0;
};
// Displays and controls touch editing elements such as selection handles.
class TouchEditingClient {
public:
TouchEditingClient() {}
// Tells the client to start showing touch editing handles.
virtual void StartTouchEditing() = 0;
// Notifies the client that touch editing is no longer needed.
virtual void EndTouchEditing() = 0;
// Notifies the client that the selection bounds need to be updated.
virtual void OnSelectionOrCursorChanged(const gfx::Rect& anchor,
const gfx::Rect& focus) = 0;
// Notifies the client that the current text input type as changed.
virtual void OnTextInputTypeChanged(ui::TextInputType type) = 0;
// Notifies the client that an input event is about to be sent to the
// renderer. Returns true if the client wants to stop event propagation.
virtual bool HandleInputEvent(const ui::Event* event) = 0;
// Notifies the client that a gesture event ack was received.
virtual void GestureEventAck(int gesture_event_type) = 0;
// This is called when the view is destroyed, so that the client can
// perform any necessary clean-up.
virtual void OnViewDestroyed() = 0;
protected:
virtual ~TouchEditingClient() {}
};
void set_paint_observer(PaintObserver* observer) {
paint_observer_ = observer;
}
void set_touch_editing_client(TouchEditingClient* client) {
touch_editing_client_ = client;
}
// RenderWidgetHostView implementation.
virtual void InitAsChild(gfx::NativeView parent_view) OVERRIDE;
virtual RenderWidgetHost* GetRenderWidgetHost() const OVERRIDE;
virtual void SetSize(const gfx::Size& size) OVERRIDE;
virtual void SetBounds(const gfx::Rect& rect) OVERRIDE;
virtual gfx::NativeView GetNativeView() const OVERRIDE;
virtual gfx::NativeViewId GetNativeViewId() const OVERRIDE;
virtual gfx::NativeViewAccessible GetNativeViewAccessible() OVERRIDE;
virtual bool HasFocus() const OVERRIDE;
virtual bool IsSurfaceAvailableForCopy() const OVERRIDE;
virtual void Show() OVERRIDE;
virtual void Hide() OVERRIDE;
virtual bool IsShowing() OVERRIDE;
virtual gfx::Rect GetViewBounds() const OVERRIDE;
virtual void SetBackground(const SkBitmap& background) OVERRIDE;
// Overridden from RenderWidgetHostViewPort:
virtual void InitAsPopup(RenderWidgetHostView* parent_host_view,
const gfx::Rect& pos) OVERRIDE;
virtual void InitAsFullscreen(
RenderWidgetHostView* reference_host_view) OVERRIDE;
virtual void WasShown() OVERRIDE;
virtual void WasHidden() OVERRIDE;
virtual void MovePluginWindows(
const gfx::Vector2d& scroll_offset,
const std::vector<WebPluginGeometry>& moves) OVERRIDE;
virtual void Focus() OVERRIDE;
virtual void Blur() OVERRIDE;
virtual void UpdateCursor(const WebCursor& cursor) OVERRIDE;
virtual void SetIsLoading(bool is_loading) OVERRIDE;
virtual void TextInputTypeChanged(ui::TextInputType type,
ui::TextInputMode input_mode,
bool can_compose_inline) OVERRIDE;
virtual void ImeCancelComposition() OVERRIDE;
virtual void ImeCompositionRangeChanged(
const gfx::Range& range,
const std::vector<gfx::Rect>& character_bounds) OVERRIDE;
virtual void DidUpdateBackingStore(
const gfx::Rect& scroll_rect,
const gfx::Vector2d& scroll_delta,
const std::vector<gfx::Rect>& copy_rects,
const ui::LatencyInfo& latency_info) OVERRIDE;
virtual void RenderProcessGone(base::TerminationStatus status,
int error_code) OVERRIDE;
virtual void Destroy() OVERRIDE;
virtual void SetTooltipText(const base::string16& tooltip_text) OVERRIDE;
virtual void SelectionChanged(const base::string16& text,
size_t offset,
const gfx::Range& range) OVERRIDE;
virtual void SelectionBoundsChanged(
const ViewHostMsg_SelectionBounds_Params& params) OVERRIDE;
virtual void ScrollOffsetChanged() OVERRIDE;
virtual BackingStore* AllocBackingStore(const gfx::Size& size) OVERRIDE;
virtual void CopyFromCompositingSurface(
const gfx::Rect& src_subrect,
const gfx::Size& dst_size,
const base::Callback<void(bool, const SkBitmap&)>& callback) OVERRIDE;
virtual void CopyFromCompositingSurfaceToVideoFrame(
const gfx::Rect& src_subrect,
const scoped_refptr<media::VideoFrame>& target,
const base::Callback<void(bool)>& callback) OVERRIDE;
virtual bool CanCopyToVideoFrame() const OVERRIDE;
virtual bool CanSubscribeFrame() const OVERRIDE;
virtual void BeginFrameSubscription(
scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber) OVERRIDE;
virtual void EndFrameSubscription() OVERRIDE;
virtual void OnAcceleratedCompositingStateChange() OVERRIDE;
virtual void AcceleratedSurfaceInitialized(int host_id,
int route_id) OVERRIDE;
virtual void AcceleratedSurfaceBuffersSwapped(
const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params_in_pixel,
int gpu_host_id) OVERRIDE;
virtual void AcceleratedSurfacePostSubBuffer(
const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params_in_pixel,
int gpu_host_id) OVERRIDE;
virtual void AcceleratedSurfaceSuspend() OVERRIDE;
virtual void AcceleratedSurfaceRelease() OVERRIDE;
virtual bool HasAcceleratedSurface(const gfx::Size& desired_size) OVERRIDE;
virtual void GetScreenInfo(blink::WebScreenInfo* results) OVERRIDE;
virtual gfx::Rect GetBoundsInRootWindow() OVERRIDE;
virtual void GestureEventAck(int gesture_event_type,
InputEventAckState ack_result) OVERRIDE;
virtual void ProcessAckedTouchEvent(
const TouchEventWithLatencyInfo& touch,
InputEventAckState ack_result) OVERRIDE;
virtual scoped_ptr<SyntheticGestureTarget> CreateSyntheticGestureTarget()
OVERRIDE;
virtual void SetHasHorizontalScrollbar(
bool has_horizontal_scrollbar) OVERRIDE;
virtual void SetScrollOffsetPinning(
bool is_pinned_to_left, bool is_pinned_to_right) OVERRIDE;
virtual gfx::GLSurfaceHandle GetCompositingSurface() OVERRIDE;
virtual void OnAccessibilityEvents(
const std::vector<AccessibilityHostMsg_EventParams>&
params) OVERRIDE;
virtual bool LockMouse() OVERRIDE;
virtual void UnlockMouse() OVERRIDE;
virtual void OnSwapCompositorFrame(
uint32 output_surface_id,
scoped_ptr<cc::CompositorFrame> frame) OVERRIDE;
#if defined(OS_WIN)
virtual void SetParentNativeViewAccessible(
gfx::NativeViewAccessible accessible_parent) OVERRIDE;
virtual gfx::NativeViewId GetParentForWindowlessPlugin() const OVERRIDE;
#endif
// Overridden from ui::TextInputClient:
virtual void SetCompositionText(
const ui::CompositionText& composition) OVERRIDE;
virtual void ConfirmCompositionText() OVERRIDE;
virtual void ClearCompositionText() OVERRIDE;
virtual void InsertText(const base::string16& text) OVERRIDE;
virtual void InsertChar(char16 ch, int flags) OVERRIDE;
virtual gfx::NativeWindow GetAttachedWindow() const OVERRIDE;
virtual ui::TextInputType GetTextInputType() const OVERRIDE;
virtual ui::TextInputMode GetTextInputMode() const OVERRIDE;
virtual bool CanComposeInline() const OVERRIDE;
virtual gfx::Rect GetCaretBounds() const OVERRIDE;
virtual bool GetCompositionCharacterBounds(uint32 index,
gfx::Rect* rect) const OVERRIDE;
virtual bool HasCompositionText() const OVERRIDE;
virtual bool GetTextRange(gfx::Range* range) const OVERRIDE;
virtual bool GetCompositionTextRange(gfx::Range* range) const OVERRIDE;
virtual bool GetSelectionRange(gfx::Range* range) const OVERRIDE;
virtual bool SetSelectionRange(const gfx::Range& range) OVERRIDE;
virtual bool DeleteRange(const gfx::Range& range) OVERRIDE;
virtual bool GetTextFromRange(const gfx::Range& range,
base::string16* text) const OVERRIDE;
virtual void OnInputMethodChanged() OVERRIDE;
virtual bool ChangeTextDirectionAndLayoutAlignment(
base::i18n::TextDirection direction) OVERRIDE;
virtual void ExtendSelectionAndDelete(size_t before, size_t after) OVERRIDE;
virtual void EnsureCaretInRect(const gfx::Rect& rect) OVERRIDE;
virtual void OnCandidateWindowShown() OVERRIDE;
virtual void OnCandidateWindowUpdated() OVERRIDE;
virtual void OnCandidateWindowHidden() OVERRIDE;
// Overridden from gfx::DisplayObserver:
virtual void OnDisplayBoundsChanged(const gfx::Display& display) OVERRIDE;
virtual void OnDisplayAdded(const gfx::Display& new_display) OVERRIDE;
virtual void OnDisplayRemoved(const gfx::Display& old_display) OVERRIDE;
// Overridden from aura::WindowDelegate:
virtual gfx::Size GetMinimumSize() const OVERRIDE;
virtual gfx::Size GetMaximumSize() const OVERRIDE;
virtual void OnBoundsChanged(const gfx::Rect& old_bounds,
const gfx::Rect& new_bounds) OVERRIDE;
virtual gfx::NativeCursor GetCursor(const gfx::Point& point) OVERRIDE;
virtual int GetNonClientComponent(const gfx::Point& point) const OVERRIDE;
virtual bool ShouldDescendIntoChildForEventHandling(
aura::Window* child,
const gfx::Point& location) OVERRIDE;
virtual bool CanFocus() OVERRIDE;
virtual void OnCaptureLost() OVERRIDE;
virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE;
virtual void OnWindowDestroying() OVERRIDE;
virtual void OnWindowDestroyed() OVERRIDE;
virtual void OnWindowTargetVisibilityChanged(bool visible) OVERRIDE;
virtual bool HasHitTestMask() const OVERRIDE;
virtual void GetHitTestMask(gfx::Path* mask) const OVERRIDE;
virtual void DidRecreateLayer(ui::Layer *old_layer,
ui::Layer *new_layer) OVERRIDE;
// Overridden from ui::EventHandler:
virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
// Overridden from aura::client::ActivationDelegate:
virtual bool ShouldActivate() const OVERRIDE;
// Overridden from aura::client::ActivationChangeObserver:
virtual void OnWindowActivated(aura::Window* gained_activation,
aura::Window* lost_activation) OVERRIDE;
// Overridden from aura::client::CursorClientObserver:
virtual void OnCursorVisibilityChanged(bool is_visible) OVERRIDE;
// Overridden from aura::client::FocusChangeObserver:
virtual void OnWindowFocused(aura::Window* gained_focus,
aura::Window* lost_focus) OVERRIDE;
// Overridden from aura::RootWindowObserver:
virtual void OnRootWindowHostMoved(const aura::RootWindow* root,
const gfx::Point& new_origin) OVERRIDE;
// SoftwareFrameManagerClient implementation:
virtual void SoftwareFrameWasFreed(
uint32 output_surface_id, unsigned frame_id) OVERRIDE;
virtual void ReleaseReferencesToSoftwareFrame() OVERRIDE;
bool CanCopyToBitmap() const;
#if defined(OS_WIN)
// Sets the cutout rects from constrained windows. These are rectangles that
// windowed NPAPI plugins shouldn't paint in. Overwrites any previous cutout
// rects.
void UpdateConstrainedWindowRects(const std::vector<gfx::Rect>& rects);
#endif
// Method to indicate if this instance is shutting down or closing.
// TODO(shrikant): Discuss around to see if it makes sense to add this method
// as part of RenderWidgetHostView.
bool IsClosing() const { return in_shutdown_; };
protected:
friend class RenderWidgetHostView;
virtual ~RenderWidgetHostViewAura();
// Should be constructed via RenderWidgetHostView::CreateViewForWidget.
explicit RenderWidgetHostViewAura(RenderWidgetHost* host);
RenderWidgetHostViewFrameSubscriber* frame_subscriber() const {
return frame_subscriber_.get();
}
virtual bool ShouldCreateResizeLock();
virtual scoped_ptr<ResizeLock> CreateResizeLock(bool defer_compositor_lock);
// Exposed for tests.
aura::Window* window() { return window_; }
gfx::Size current_frame_size() const { return current_frame_size_; }
// Overridden from ui::CompositorObserver:
virtual void OnCompositingDidCommit(ui::Compositor* compositor) OVERRIDE;
virtual void OnCompositingStarted(ui::Compositor* compositor,
base::TimeTicks start_time) OVERRIDE;
virtual void OnCompositingEnded(ui::Compositor* compositor) OVERRIDE;
virtual void OnCompositingAborted(ui::Compositor* compositor) OVERRIDE;
virtual void OnCompositingLockStateChanged(
ui::Compositor* compositor) OVERRIDE;
virtual void OnUpdateVSyncParameters(ui::Compositor* compositor,
base::TimeTicks timebase,
base::TimeDelta interval) OVERRIDE;
private:
FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest, SetCompositionText);
FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest, TouchEventState);
FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest, TouchEventSyncAsync);
FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest, SwapNotifiesWindow);
FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest,
SkippedDelegatedFrames);
FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest, OutputSurfaceIdChange);
FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest,
DiscardDelegatedFrames);
FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostViewAuraTest, SoftwareDPIChange);
class WindowObserver;
friend class WindowObserver;
// Overridden from ImageTransportFactoryObserver:
virtual void OnLostResources() OVERRIDE;
// Overridden from BrowserAccessibilityDelegate:
virtual void SetAccessibilityFocus(int acc_obj_id) OVERRIDE;
virtual void AccessibilityDoDefaultAction(int acc_obj_id) OVERRIDE;
virtual void AccessibilityScrollToMakeVisible(
int acc_obj_id, gfx::Rect subfocus) OVERRIDE;
virtual void AccessibilityScrollToPoint(
int acc_obj_id, gfx::Point point) OVERRIDE;
virtual void AccessibilitySetTextSelection(
int acc_obj_id, int start_offset, int end_offset) OVERRIDE;
virtual gfx::Point GetLastTouchEventLocation() const OVERRIDE;
virtual void FatalAccessibilityTreeError() OVERRIDE;
void UpdateCursorIfOverSelf();
bool ShouldSkipFrame(gfx::Size size_in_dip) const;
// Set the bounds of the window and handle size changes. Assumes the caller
// has already adjusted the origin of |rect| to conform to whatever coordinate
// space is required by the aura::Window.
void InternalSetBounds(const gfx::Rect& rect);
// Lazily grab a resize lock if the aura window size doesn't match the current
// frame size, to give time to the renderer.
void MaybeCreateResizeLock();
// Checks if the resize lock can be released because we received an new frame.
void CheckResizeLock();
void UpdateExternalTexture();
ui::InputMethod* GetInputMethod() const;
// Returns whether the widget needs an input grab to work properly.
bool NeedsInputGrab();
// Confirm existing composition text in the webpage and ask the input method
// to cancel its ongoing composition session.
void FinishImeCompositionSession();
// This method computes movementX/Y and keeps track of mouse location for
// mouse lock on all mouse move events.
void ModifyEventMovementAndCoords(blink::WebMouseEvent* event);
// Sends an IPC to the renderer process to communicate whether or not
// the mouse cursor is visible anywhere on the screen.
void NotifyRendererOfCursorVisibilityState(bool is_visible);
// If |clip| is non-empty and and doesn't contain |rect| or |clip| is empty
// SchedulePaint() is invoked for |rect|.
void SchedulePaintIfNotInClip(const gfx::Rect& rect, const gfx::Rect& clip);
// Helper method to determine if, in mouse locked mode, the cursor should be
// moved to center.
bool ShouldMoveToCenter();
// Run all on compositing commit callbacks.
void RunOnCommitCallbacks();
// Add on compositing commit callback.
void AddOnCommitCallbackAndDisableLocks(const base::Closure& callback);
// Called after |window_| is parented to a RootWindow.
void AddedToRootWindow();
// Called prior to removing |window_| from a RootWindow.
void RemovingFromRootWindow();
// Called after commit for the last reference to the texture going away
// after it was released as the frontbuffer.
void SetSurfaceNotInUseByCompositor(scoped_refptr<ui::Texture>);
// Called after async thumbnailer task completes. Scales and crops the result
// of the copy.
static void CopyFromCompositingSurfaceHasResult(
const gfx::Size& dst_size_in_pixel,
const base::Callback<void(bool, const SkBitmap&)>& callback,
scoped_ptr<cc::CopyOutputResult> result);
static void PrepareTextureCopyOutputResult(
const gfx::Size& dst_size_in_pixel,
const base::Callback<void(bool, const SkBitmap&)>& callback,
scoped_ptr<cc::CopyOutputResult> result);
static void PrepareBitmapCopyOutputResult(
const gfx::Size& dst_size_in_pixel,
const base::Callback<void(bool, const SkBitmap&)>& callback,
scoped_ptr<cc::CopyOutputResult> result);
static void CopyFromCompositingSurfaceHasResultForVideo(
base::WeakPtr<RenderWidgetHostViewAura> rwhva,
scoped_refptr<OwnedMailbox> subscriber_texture,
scoped_refptr<media::VideoFrame> video_frame,
const base::Callback<void(bool)>& callback,
scoped_ptr<cc::CopyOutputResult> result);
static void CopyFromCompositingSurfaceFinishedForVideo(
base::WeakPtr<RenderWidgetHostViewAura> rwhva,
const base::Callback<void(bool)>& callback,
scoped_refptr<OwnedMailbox> subscriber_texture,
scoped_ptr<cc::SingleReleaseCallback> release_callback,
bool result);
ui::Compositor* GetCompositor() const;
// Detaches |this| from the input method object.
void DetachFromInputMethod();
// Dismisses a Web Popup on mouse press outside the popup and its parent.
void ApplyEventFilterForPopupExit(ui::MouseEvent* event);
// Converts |rect| from window coordinate to screen coordinate.
gfx::Rect ConvertRectToScreen(const gfx::Rect& rect) const;
// Converts |rect| from screen coordinate to window coordinate.
gfx::Rect ConvertRectFromScreen(const gfx::Rect& rect) const;
typedef base::Callback<void(bool, const scoped_refptr<ui::Texture>&)>
BufferPresentedCallback;
// The common entry point for buffer updates from renderer
// and GPU process.
void BuffersSwapped(const gfx::Size& surface_size,
const gfx::Rect& damage_rect,
float surface_scale_factor,
const std::string& mailbox_name,
const ui::LatencyInfo& latency_info,
const BufferPresentedCallback& ack_callback);
bool SwapBuffersPrepare(const gfx::Rect& surface_rect,
float surface_scale_factor,
const gfx::Rect& damage_rect,
const std::string& mailbox_name,
const BufferPresentedCallback& ack_callback);
void SwapBuffersCompleted(
const BufferPresentedCallback& ack_callback,
const scoped_refptr<ui::Texture>& texture_to_return);
void SwapDelegatedFrame(
uint32 output_surface_id,
scoped_ptr<cc::DelegatedFrameData> frame_data,
float frame_device_scale_factor,
const ui::LatencyInfo& latency_info);
void SendDelegatedFrameAck(uint32 output_surface_id);
void SendReturnedDelegatedResources(uint32 output_surface_id);
// DelegatedFrameEvictorClient implementation.
virtual void EvictDelegatedFrame() OVERRIDE;
// cc::DelegatedFrameProviderClient implementation.
virtual void UnusedResourcesAreAvailable() OVERRIDE;
void SwapSoftwareFrame(uint32 output_surface_id,
scoped_ptr<cc::SoftwareFrameData> frame_data,
float frame_device_scale_factor,
const ui::LatencyInfo& latency_info);
void SendSoftwareFrameAck(uint32 output_surface_id);
void SendReclaimSoftwareFrames();
void ReleaseSoftwareFrame(uint32 output_surface_id,
unsigned software_frame_id);
void DidReceiveFrameFromRenderer();
BrowserAccessibilityManager* GetOrCreateBrowserAccessibilityManager();
// Helper function to set keyboard focus to the main window.
void SetKeyboardFocus();
#if defined(OS_WIN)
// Updates the total list of cutout rects, which is the union of transient
// windows and constrained windows.
void UpdateCutoutRects();
#endif
// The model object.
RenderWidgetHostImpl* host_;
aura::Window* window_;
scoped_ptr<WindowObserver> window_observer_;
// Are we in the process of closing? Tracked so fullscreen views can avoid
// sending a second shutdown request to the host when they lose the focus
// after requesting shutdown for another reason (e.g. Escape key).
bool in_shutdown_;
// True if in the process of handling a window bounds changed notification.
bool in_bounds_changed_;
// Is this a fullscreen view?
bool is_fullscreen_;
// Our parent host view, if this is a popup. NULL otherwise.
RenderWidgetHostViewAura* popup_parent_host_view_;
// Our child popup host. NULL if we do not have a child popup.
RenderWidgetHostViewAura* popup_child_host_view_;
class EventFilterForPopupExit;
friend class EventFilterForPopupExit;
scoped_ptr<ui::EventHandler> event_filter_for_popup_exit_;
// True when content is being loaded. Used to show an hourglass cursor.
bool is_loading_;
// The cursor for the page. This is passed up from the renderer.
WebCursor current_cursor_;
// The touch-event. Its touch-points are updated as necessary. A new
// touch-point is added from an ET_TOUCH_PRESSED event, and a touch-point is
// removed from the list on an ET_TOUCH_RELEASED event.
blink::WebTouchEvent touch_event_;
// The current text input type.
ui::TextInputType text_input_type_;
// The current text input mode corresponding to HTML5 inputmode attribute.
ui::TextInputMode text_input_mode_;
bool can_compose_inline_;
// Rectangles for the selection anchor and focus.
gfx::Rect selection_anchor_rect_;
gfx::Rect selection_focus_rect_;
// The current composition character bounds.
std::vector<gfx::Rect> composition_character_bounds_;
// Indicates if there is onging composition text.
bool has_composition_text_;
// Whether return characters should be passed on to the RenderWidgetHostImpl.
bool accept_return_character_;
// Current tooltip text.
base::string16 tooltip_;
std::vector<base::Closure> on_compositing_did_commit_callbacks_;
// The current frontbuffer texture.
scoped_refptr<ui::Texture> current_surface_;
// This holds the current software framebuffer, if any.
scoped_ptr<SoftwareFrameManager> software_frame_manager_;
// With delegated renderer, this is the last output surface, used to
// disambiguate resources with the same id coming from different output
// surfaces.
uint32 last_output_surface_id_;
// The number of delegated frame acks that are pending, to delay resource
// returns until the acks are sent.
int pending_delegated_ack_count_;
// The damage in the previously presented buffer.
SkRegion previous_damage_;
// Pending damage from previous frames that we skipped.
SkRegion skipped_damage_;
// True after a delegated frame has been skipped, until a frame is not
// skipped.
bool skipped_frames_;
// Holds delegated resources that have been given to a DelegatedFrameProvider,
// and gives back resources when they are no longer in use for return to the
// renderer.
scoped_refptr<cc::DelegatedFrameResourceCollection> resource_collection_;
// Provides delegated frame updates to the cc::DelegatedRendererLayer.
scoped_refptr<cc::DelegatedFrameProvider> frame_provider_;
// The size of the last frame that was swapped (even if we skipped it).
// Used to determine when the skipped_damage_ needs to be reset due to
// size changes between front- and backbuffer.
gfx::Size last_swapped_surface_size_;
float last_swapped_surface_scale_factor_;
// If non-NULL we're in OnPaint() and this is the supplied canvas.
gfx::Canvas* paint_canvas_;
// Used to record the last position of the mouse.
// While the mouse is locked, they store the last known position just as mouse
// lock was entered.
// Relative to the upper-left corner of the view.
gfx::Point unlocked_mouse_position_;
// Relative to the upper-left corner of the screen.
gfx::Point unlocked_global_mouse_position_;
// Last cursor position relative to screen. Used to compute movementX/Y.
gfx::Point global_mouse_position_;
// In mouse locked mode, we syntheticaly move the mouse cursor to the center
// of the window when it reaches the window borders to avoid it going outside.
// This flag is used to differentiate between these synthetic mouse move
// events vs. normal mouse move events.
bool synthetic_move_sent_;
// Signals that the accelerated compositing has been turned on or off.
// This is used to signal to turn off the external texture as soon as the
// software backing store is updated.
bool accelerated_compositing_state_changed_;
// This lock is the one waiting for a frame of the right size to come back
// from the renderer/GPU process. It is set from the moment the aura window
// got resized, to the moment we committed the renderer frame of the same
// size. It keeps track of the size we expect from the renderer, and locks the
// compositor, as well as the UI for a short time to give a chance to the
// renderer of producing a frame of the right size.
scoped_ptr<ResizeLock> resize_lock_;
// Keeps track of the current frame size.
gfx::Size current_frame_size_;
// This lock is for waiting for a front surface to become available to draw.
scoped_refptr<ui::CompositorLock> released_front_lock_;
// Used to track the state of the window we're created from. Only used when
// created fullscreen.
scoped_ptr<aura::WindowTracker> host_tracker_;
enum CanLockCompositorState {
YES,
// We locked, so at some point we'll need to kick a frame.
YES_DID_LOCK,
// No. A lock timed out, we need to kick a new frame before locking again.
NO_PENDING_RENDERER_FRAME,
// No. We've got a frame, but it hasn't been committed.
NO_PENDING_COMMIT,
};
CanLockCompositorState can_lock_compositor_;
// Used to track the last cursor visibility update that was sent to the
// renderer via NotifyRendererOfCursorVisibilityState().
enum CursorVisibilityState {
UNKNOWN,
VISIBLE,
NOT_VISIBLE,
};
CursorVisibilityState cursor_visibility_state_in_renderer_;
// An observer to notify that the paint content of the view has changed. The
// observer is not owned by the view, and must remove itself as an oberver
// when it is being destroyed.
PaintObserver* paint_observer_;
#if defined(OS_WIN)
// The list of rectangles from constrained windows over this view. Windowed
// NPAPI plugins shouldn't draw over them.
std::vector<gfx::Rect> constrained_rects_;
typedef std::map<HWND, WebPluginGeometry> PluginWindowMoves;
// Contains information about each windowed plugin's clip and cutout rects (
// from the renderer). This is needed because when the transient windoiws
// over this view changes, we need this information in order to create a new
// region for the HWND.
PluginWindowMoves plugin_window_moves_;
#endif
base::TimeTicks last_draw_ended_;
// Subscriber that listens to frame presentation events.
scoped_ptr<RenderWidgetHostViewFrameSubscriber> frame_subscriber_;
std::vector<scoped_refptr<OwnedMailbox> > idle_frame_subscriber_textures_;
// YUV readback pipeline.
scoped_ptr<content::ReadbackYUVInterface>
yuv_readback_pipeline_;
TouchEditingClient* touch_editing_client_;
ui::LatencyInfo software_latency_info_;
struct ReleasedFrameInfo {
ReleasedFrameInfo(uint32 output_id, unsigned software_frame_id)
: output_surface_id(output_id), frame_id(software_frame_id) {}
uint32 output_surface_id;
unsigned frame_id;
};
scoped_ptr<ReleasedFrameInfo> released_software_frame_;
scoped_ptr<DelegatedFrameEvictor> delegated_frame_evictor_;
base::WeakPtrFactory<RenderWidgetHostViewAura> weak_ptr_factory_;
#if defined(OS_WIN)
// The dummy HWND which corresponds to the bounds of the web page. This is
// passed to windowless plugins like Flash/Silverlight, etc as the
// container window.
HWND plugin_parent_window_;
#endif
DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewAura);
};
} // namespace content
#endif // CONTENT_BROWSER_RENDERER_HOST_RENDER_WIDGET_HOST_VIEW_AURA_H_
|