Revert "Fix delegated ink trails in OOPIF"
This reverts commit b8c06872c6cfa5a1be26bd0f801aa1f350538fd7.
Reason for revert: crbug.com/1215704
Original change's description:
> Fix delegated ink trails in OOPIF
>
> Today, delegated ink trails do not work in OOPIFs. The
> RenderFrameMetadata with the delegated ink flag set on it arrives in a
> provider held by RenderWidgetHostImpl that is associated with the OOPIF.
> This makes sense, but the issue is that the OOPIF's view is a
> RenderWidgetHostViewChildFrame, which does not hold an EventHandler.
> Then, when future pointerevents arrive in the browser, they are not
> checking the correct widget for a delegated ink flag. Therefore, points
> are not being forwarded for delegated ink trails.
>
> This fix moves the place that we decide to forward delegated ink points
> into the RenderWidgetHostInputEventRouter, which is slightly later in
> the execution. By doing this, hit testing will have occurred and we
> will have the RenderWidgetHostViewChildFrame as the target, allowing us
> to directly query that view's widget for a delegated ink flag. Then
> forwarding will work as it did from RenderWidgetHostViewEventHandler.
>
> Bug: 1052145
> Change-Id: I0b22b98ae73be97217c0b45cf2e5c3e6a4e32577
> Cq-Do-Not-Cancel-Tryjobs: true
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2857102
> Reviewed-by: Ken Buchanan <kenrb@chromium.org>
> Reviewed-by: Jonathan Ross <jonross@chromium.org>
> Reviewed-by: Scott Violet <sky@chromium.org>
> Reviewed-by: Daniel Libby <dlibby@microsoft.com>
> Commit-Queue: Mario Bianucci <mabian@microsoft.com>
> Cr-Commit-Position: refs/heads/master@{#888498}
Bug: 1052145, 1215704
Change-Id: I501df4b3fe9736cbed5d677ae72906cb331bb347
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2935138
Auto-Submit: François Doray <fdoray@chromium.org>
Bot-Commit: Rubber Stamper <rubber-stamper@appspot.gserviceaccount.com>
Commit-Queue: François Doray <fdoray@chromium.org>
Owners-Override: François Doray <fdoray@chromium.org>
Cr-Commit-Position: refs/heads/master@{#888609}
diff --git a/content/browser/renderer_host/render_frame_metadata_provider_impl.h b/content/browser/renderer_host/render_frame_metadata_provider_impl.h
index 3d68f96..bfcd03de 100644
--- a/content/browser/renderer_host/render_frame_metadata_provider_impl.h
+++ b/content/browser/renderer_host/render_frame_metadata_provider_impl.h
@@ -60,7 +60,6 @@
private:
friend class FakeRenderWidgetHostViewAura;
- friend class DelegatedInkPointTest;
// Paired with the mojom::RenderFrameMetadataObserverClient overrides, these
// methods are enqueued in |frame_token_message_queue_|. They are invoked when
diff --git a/content/browser/renderer_host/render_widget_host_input_event_router.cc b/content/browser/renderer_host/render_widget_host_input_event_router.cc
index b2e08a8..893c804 100644
--- a/content/browser/renderer_host/render_widget_host_input_event_router.cc
+++ b/content/browser/renderer_host/render_widget_host_input_event_router.cc
@@ -14,7 +14,6 @@
#include "base/metrics/histogram_macros.h"
#include "base/stl_util.h"
#include "base/strings/stringprintf.h"
-#include "base/trace_event/trace_event.h"
#include "components/viz/common/features.h"
#include "components/viz/common/hit_test/hit_test_region_list.h"
#include "components/viz/common/quads/surface_draw_quad.h"
@@ -28,7 +27,6 @@
#include "content/public/browser/render_widget_host_iterator.h"
#include "third_party/blink/public/common/input/web_input_event.h"
#include "ui/base/layout.h"
-#include "ui/compositor/compositor.h"
#include "ui/gfx/geometry/dip_util.h"
namespace {
@@ -643,14 +641,6 @@
mouse_capture_target_ = target;
}
- if (target) {
- ui::EventType type = mouse_event.GetTypeAsUiEventType();
- bool hovering =
- (type ^ ui::ET_MOUSE_DRAGGED) && (type ^ ui::ET_MOUSE_PRESSED);
- ForwardDelegatedInkPoint(target, root_view, mouse_event, mouse_event,
- hovering);
- }
-
DCHECK(target_location.has_value());
blink::WebMouseEvent event = mouse_event;
event.SetPositionInWidget(target_location->x(), target_location->y());
@@ -875,11 +865,6 @@
base::debug::DumpWithoutCrashing();
}
- if (touch_target_) {
- ForwardDelegatedInkPoint(touch_target_, root_view, touch_event,
- touch_event.touches[0], touch_event.hovering);
- }
-
TouchEventAckQueue::TouchEventSource event_source =
is_emulated_touchevent
? TouchEventAckQueue::TouchEventSource::EmulatedTouchEvent
@@ -2003,71 +1988,4 @@
event_targeter_->SetIsAutoScrollInProgress(is_autoscroll_in_progress);
}
-bool IsMoveEvent(ui::EventType type) {
- return type == ui::ET_MOUSE_MOVED || type == ui::ET_MOUSE_DRAGGED ||
- type == ui::ET_TOUCH_MOVED;
-}
-
-void RenderWidgetHostInputEventRouter::ForwardDelegatedInkPoint(
- RenderWidgetHostViewBase* target_view,
- RenderWidgetHostViewBase* root_view,
- const blink::WebInputEvent& input_event,
- const blink::WebPointerProperties& pointer_properties,
- bool hovering) {
- const absl::optional<cc::DelegatedInkBrowserMetadata>& metadata =
- target_view->host()
- ->render_frame_metadata_provider()
- ->LastRenderFrameMetadata()
- .delegated_ink_metadata;
-
- if (IsMoveEvent(input_event.GetTypeAsUiEventType()) && metadata &&
- hovering == metadata.value().delegated_ink_is_hovering) {
- if (!delegated_ink_point_renderer_.is_bound()) {
- ui::Compositor* compositor = target_view->GetCompositor();
-
- // The remote can't be bound if the compositor is null, so bail if that
- // is the case so we don't crash by trying to use an unbound remote.
- if (!compositor)
- return;
-
- TRACE_EVENT_INSTANT0("input",
- "Binding mojo interface for delegated ink points.",
- TRACE_EVENT_SCOPE_THREAD);
- compositor->SetDelegatedInkPointRenderer(
- delegated_ink_point_renderer_.BindNewPipeAndPassReceiver());
- delegated_ink_point_renderer_.reset_on_disconnect();
- }
-
- gfx::PointF position = pointer_properties.PositionInWidget();
- root_view->TransformPointToRootSurface(&position);
- position.Scale(target_view->GetDeviceScaleFactor());
-
- gfx::DelegatedInkPoint delegated_ink_point(
- position, input_event.TimeStamp(), pointer_properties.id);
- TRACE_EVENT_INSTANT1("input",
- "Forwarding delegated ink point from browser.",
- TRACE_EVENT_SCOPE_THREAD, "delegated point",
- delegated_ink_point.ToString());
-
- // Calling this will result in IPC calls to get |delegated_ink_point| to
- // viz. The decision to do this here was made with the understanding that
- // the IPC overhead will result in a minor increase in latency for getting
- // this event to the renderer. However, by sending it here, the event is
- // given the greatest possible chance to make it to viz before
- // DrawAndSwap() is called, allowing more points to be drawn as part of
- // the delegated ink trail, and thus reducing user perceived latency.
- delegated_ink_point_renderer_->StoreDelegatedInkPoint(delegated_ink_point);
- ended_delegated_ink_trail_ = false;
- } else if (delegated_ink_point_renderer_.is_bound() &&
- !ended_delegated_ink_trail_) {
- // Let viz know that the most recent point it received from us is probably
- // the last point the user is inking, so it shouldn't predict anything
- // beyond it.
- TRACE_EVENT_INSTANT0("input", "Delegated ink trail ended",
- TRACE_EVENT_SCOPE_THREAD);
- delegated_ink_point_renderer_->ResetPrediction();
- ended_delegated_ink_trail_ = true;
- }
-}
-
} // namespace content
diff --git a/content/browser/renderer_host/render_widget_host_input_event_router.h b/content/browser/renderer_host/render_widget_host_input_event_router.h
index b850e9e..3550833 100644
--- a/content/browser/renderer_host/render_widget_host_input_event_router.h
+++ b/content/browser/renderer_host/render_widget_host_input_event_router.h
@@ -23,10 +23,8 @@
#include "content/browser/renderer_host/render_widget_host_view_base_observer.h"
#include "content/browser/renderer_host/render_widget_targeter.h"
#include "content/common/content_export.h"
-#include "mojo/public/cpp/bindings/remote.h"
#include "third_party/blink/public/mojom/input/input_event_result.mojom-shared.h"
#include "ui/gfx/geometry/vector2d_conversions.h"
-#include "ui/gfx/mojom/delegated_ink_point_renderer.mojom.h"
#include "ui/gfx/transform.h"
namespace blink {
@@ -34,7 +32,6 @@
class WebInputEvent;
class WebMouseEvent;
class WebMouseWheelEvent;
-class WebPointerProperties;
class WebTouchEvent;
}
@@ -335,18 +332,6 @@
void SetTouchscreenGestureTarget(RenderWidgetHostViewBase* target,
bool moved_recently = false);
- void ForwardDelegatedInkPoint(
- RenderWidgetHostViewBase* target_view,
- RenderWidgetHostViewBase* root_view,
- const blink::WebInputEvent& input_event,
- const blink::WebPointerProperties& pointer_properties,
- bool hovering);
-
- void FlushForTest() { delegated_ink_point_renderer_.FlushForTesting(); }
- bool IsDelegatedInkRendererBoundForTest() {
- return delegated_ink_point_renderer_.is_bound();
- }
-
FrameSinkIdOwnerMap owner_map_;
TargetMap touchscreen_gesture_target_map_;
RenderWidgetHostViewBase* touch_target_ = nullptr;
@@ -444,18 +429,6 @@
// Used to prevent multiple dumps.
bool has_dumped_ = false;
- // Remote end of the connection for sending delegated ink points to viz to
- // support the delegated ink trails feature.
- mojo::Remote<gfx::mojom::DelegatedInkPointRenderer>
- delegated_ink_point_renderer_;
- // Used to know if we have already told viz to reset prediction because the
- // final point of the delegated ink trail has been sent. True when prediction
- // has already been reset for the most recent trail, false otherwise. This
- // flag helps make sure that we don't send more IPCs than necessary to viz to
- // reset prediction. Sending extra IPCs wouldn't impact correctness, but can
- // impact performance due to the IPC overhead.
- bool ended_delegated_ink_trail_ = false;
-
base::WeakPtrFactory<RenderWidgetHostInputEventRouter> weak_ptr_factory_{
this};
@@ -477,8 +450,6 @@
InputEventRouterWheelTargetTest);
FRIEND_TEST_ALL_PREFIXES(SitePerProcessMacBrowserTest,
InputEventRouterTouchpadGestureTargetTest);
- FRIEND_TEST_ALL_PREFIXES(SitePerProcessDelegatedInkBrowserTest,
- MetadataAndPointGoThroughOOPIF);
};
} // namespace content
diff --git a/content/browser/renderer_host/render_widget_host_input_event_router_unittest.cc b/content/browser/renderer_host/render_widget_host_input_event_router_unittest.cc
index 9db386e..fe41ab1 100644
--- a/content/browser/renderer_host/render_widget_host_input_event_router_unittest.cc
+++ b/content/browser/renderer_host/render_widget_host_input_event_router_unittest.cc
@@ -31,13 +31,6 @@
#include "third_party/blink/public/common/input/synthetic_web_input_event_builders.h"
#include "third_party/blink/public/mojom/input/touch_event.mojom.h"
-#if defined(USE_AURA)
-#include "ui/aura/test/aura_test_helper.h"
-#include "ui/aura/test/test_screen.h"
-#include "ui/aura/window_tree_host.h"
-#include "ui/gfx/mojom/delegated_ink_point_renderer.mojom.h"
-#endif // defined(USE_AURA)
-
namespace content {
namespace {
@@ -107,15 +100,10 @@
void Reset() { last_gesture_seen_ = blink::WebInputEvent::Type::kUndefined; }
- void SetCompositor(ui::Compositor* compositor) { compositor_ = compositor; }
- ui::Compositor* GetCompositor() override { return compositor_; }
-
private:
blink::WebInputEvent::Type last_gesture_seen_ =
blink::WebInputEvent::Type::kUndefined;
uint32_t unique_id_for_last_touch_ack_ = 0;
-
- ui::Compositor* compositor_;
};
class StubHitTestQuery : public viz::HitTestQuery {
@@ -348,8 +336,6 @@
RenderWidgetHostViewBase* gesture_target,
bool should_cancel);
- void FlushInkRenderer() { rwhier()->FlushForTest(); }
-
BrowserTaskEnvironment task_environment_;
MockRenderWidgetHostDelegate delegate_;
@@ -1059,505 +1045,4 @@
base::RunLoop().RunUntilIdle();
}
-#if defined(USE_AURA)
-// Mock the DelegatedInkPointRenderer to grab the delegated ink points as they
-// are shipped off to viz from the browser process.
-class MockDelegatedInkPointRenderer
- : public gfx::mojom::DelegatedInkPointRenderer {
- public:
- explicit MockDelegatedInkPointRenderer(
- mojo::PendingReceiver<gfx::mojom::DelegatedInkPointRenderer> receiver)
- : receiver_(this, std::move(receiver)) {}
-
- void StoreDelegatedInkPoint(const gfx::DelegatedInkPoint& point) override {
- delegated_ink_point_ = point;
- }
-
- bool HasDelegatedInkPoint() { return delegated_ink_point_.has_value(); }
-
- gfx::DelegatedInkPoint GetDelegatedInkPoint() {
- gfx::DelegatedInkPoint point = delegated_ink_point_.value();
- delegated_ink_point_.reset();
- return point;
- }
-
- void ClearDelegatedInkPoint() { delegated_ink_point_.reset(); }
-
- void ResetPrediction() override { prediction_reset_ = true; }
- bool GetPredictionState() {
- bool state = prediction_reset_;
- prediction_reset_ = false;
- return state;
- }
-
- void FlushForTesting() { receiver_.FlushForTesting(); }
-
- void ResetReceiver() { receiver_.reset(); }
- bool ReceiverIsBound() { return receiver_.is_bound(); }
-
- private:
- mojo::Receiver<gfx::mojom::DelegatedInkPointRenderer> receiver_;
- absl::optional<gfx::DelegatedInkPoint> delegated_ink_point_;
- bool prediction_reset_ = false;
-};
-
-// MockCompositor class binds the mojo interfaces so that the ink points are
-// shipped to the browser process. Uses values from the real compositor to be
-// created, but a fake FrameSinkId must be used so that it hasn't already been
-// registered.
-class MockCompositor : public ui::Compositor {
- public:
- explicit MockCompositor(ui::Compositor* compositor)
- : ui::Compositor(viz::FrameSinkId(5, 5),
- compositor->context_factory(),
- compositor->task_runner(),
- compositor->is_pixel_canvas()) {}
-
- void SetDelegatedInkPointRenderer(
- mojo::PendingReceiver<gfx::mojom::DelegatedInkPointRenderer> receiver)
- override {
- delegated_ink_point_renderer_ =
- std::make_unique<MockDelegatedInkPointRenderer>(std::move(receiver));
- }
-
- MockDelegatedInkPointRenderer* delegated_ink_point_renderer() {
- return delegated_ink_point_renderer_.get();
- }
-
- private:
- std::unique_ptr<MockDelegatedInkPointRenderer> delegated_ink_point_renderer_;
-};
-
-enum TestEvent { kMouseEvent, kTouchEvent };
-enum HoveringState { kHovering, kNotHovering };
-
-class DelegatedInkPointTest
- : public RenderWidgetHostInputEventRouterTest,
- public testing::WithParamInterface<std::tuple<TestEvent, HoveringState>> {
- public:
- DelegatedInkPointTest() = default;
-
- void SetUp() override {
- RenderWidgetHostInputEventRouterTest::SetUp();
-
- aura_test_helper_ = std::make_unique<aura::test::AuraTestHelper>(
- ImageTransportFactory::GetInstance()->GetContextFactory());
- aura_test_helper_->SetUp();
-
- compositor_ = std::make_unique<MockCompositor>(
- aura_test_helper_->GetHost()->compositor());
- view_root_->SetCompositor(compositor_.get());
- }
-
- void TearDown() override {
- aura_test_helper_->TearDown();
- compositor_.reset();
- RenderWidgetHostInputEventRouterTest::TearDown();
- }
-
- TestEvent GetEventParam() { return std::get<0>(GetParam()); }
- HoveringState GetHoverParam() { return std::get<1>(GetParam()); }
-
- void SetInkMetadataFlagOnRenderFrameMetadata(bool delegated_ink) {
- SetInkMetadataFlagOnSpecificHost(delegated_ink, widget_host_root_.get());
- }
-
- void SetInkMetadataFlagOnSpecificHost(bool delegated_ink,
- RenderWidgetHostImpl* widget_host) {
- cc::RenderFrameMetadata metadata;
- if (delegated_ink) {
- metadata.delegated_ink_metadata = cc::DelegatedInkBrowserMetadata(
- GetHoverParam() == HoveringState::kHovering);
- }
- widget_host->render_frame_metadata_provider()
- ->SetLastRenderFrameMetadataForTest(metadata);
- }
-
- void SendEvent(bool match_test_hovering_state,
- gfx::PointF point,
- base::TimeTicks timestamp = base::TimeTicks::Now()) {
- SendEvent(match_test_hovering_state, point, timestamp,
- /*use_enter_event*/ false, /*use_exit_event*/ false);
- }
-
- void SendEvent(bool match_test_hovering_state,
- const gfx::PointF& point,
- base::TimeTicks timestamp,
- bool use_enter_event,
- bool use_exit_event) {
- DCHECK(!(use_enter_event && use_exit_event));
-
- // Hovering creates and sends ui::MouseEvents with
- // ET_MOUSE_{MOVED,ENTERED,EXITED} types, so do the same here in hovering
- // scenarios.
- if (GetEventParam() == TestEvent::kTouchEvent &&
- !Hovering(match_test_hovering_state)) {
- blink::WebInputEvent::Type event_type =
- blink::WebInputEvent::Type::kTouchMove;
- blink::WebTouchPoint::State touch_state =
- blink::WebTouchPoint::State::kStateMoved;
- if (use_enter_event) {
- event_type = blink::WebInputEvent::Type::kTouchStart;
- touch_state = blink::WebTouchPoint::State::kStatePressed;
- // Set this now so that if we are going to send a enter event anyway,
- // we don't send two.
- sent_touch_press_ = true;
- }
- if (use_exit_event) {
- event_type = blink::WebInputEvent::Type::kTouchEnd;
- touch_state = blink::WebTouchPoint::State::kStateReleased;
- }
-
- // Touch needs a pressed event first to properly handle future move
- // events.
- SendTouchPress(point);
-
- blink::WebTouchEvent touch_event(
- event_type, blink::WebInputEvent::kNoModifiers, timestamp);
- touch_event.touches_length = 1;
- touch_event.touches[0].id = kPointerId;
- touch_event.touches[0].SetPositionInWidget(point);
- touch_event.touches[0].state = touch_state;
- touch_event.unique_touch_event_id = GetTouchId();
-
- rwhier()->RouteTouchEvent(view_root_.get(), &touch_event,
- ui::LatencyInfo(ui::SourceEventType::TOUCH));
-
- // Need to send a new press event after ending the previous touch.
- if (use_exit_event)
- sent_touch_press_ = false;
- } else {
- blink::WebInputEvent::Type event_type =
- blink::WebInputEvent::Type::kMouseMove;
- if (use_enter_event)
- event_type = blink::WebInputEvent::Type::kMouseEnter;
- if (use_exit_event)
- event_type = blink::WebInputEvent::Type::kMouseLeave;
-
- int modifiers = 0;
- if (!Hovering(match_test_hovering_state))
- modifiers = blink::WebInputEvent::kLeftButtonDown;
-
- blink::WebMouseEvent mouse_event(event_type, modifiers, timestamp,
- kPointerId);
- mouse_event.SetPositionInWidget(point);
-
- rwhier()->RouteMouseEvent(view_root_.get(), &mouse_event,
- ui::LatencyInfo(ui::SourceEventType::MOUSE));
- }
- }
-
- void SetDeviceScaleFactor(float dsf) {
- aura_test_helper_->GetTestScreen()->SetDeviceScaleFactor(dsf);
- }
-
- MockCompositor* compositor() { return compositor_.get(); }
-
- int32_t GetExpectedPointerId() const { return kPointerId; }
-
- private:
- void SendTouchPress(const gfx::PointF& requested_touch_location) {
- DCHECK(GetEventParam() == TestEvent::kTouchEvent);
- if (sent_touch_press_)
- return;
-
- // Location of the press event doesn't matter, so long as it doesn't exactly
- // match the location of the subsequent move event. If they match, then the
- // move event is dropped.
- gfx::PointF point(requested_touch_location.x() + 2.f,
- requested_touch_location.y() + 2.f);
-
- // Send a TouchStart/End sequence.
- blink::WebTouchEvent press(
- blink::WebInputEvent::Type::kTouchStart,
- blink::WebInputEvent::kNoModifiers,
- blink::WebInputEvent::GetStaticTimeStampForTests());
- press.touches_length = 1;
- press.touches[0].id = kPointerId;
- press.touches[0].SetPositionInWidget(point);
- press.touches[0].state = blink::WebTouchPoint::State::kStatePressed;
- press.unique_touch_event_id = GetTouchId();
-
- rwhier()->RouteTouchEvent(view_root_.get(), &press,
- ui::LatencyInfo(ui::SourceEventType::TOUCH));
- sent_touch_press_ = true;
- }
-
- bool Hovering(bool match_test_hovering_state) {
- return (GetHoverParam() == HoveringState::kHovering &&
- match_test_hovering_state) ||
- (GetHoverParam() == HoveringState::kNotHovering &&
- !match_test_hovering_state);
- }
-
- // Unique touch id is unique per event, so always increment before providing
- // a new one.
- int GetTouchId() { return ++unique_touch_id_; }
-
- // Pointer id to use in these tests. It must be consistent throughout a single
- // test for some of the touch variations.
- const int32_t kPointerId = 5;
-
- // Touch events are ignored if a press isn't sent first, so use this to track
- // if we have already sent a touch press event yet or not.
- bool sent_touch_press_ = false;
-
- // Most recently used unique touch id for blink::WebTouchEvents
- int unique_touch_id_ = 0;
-
- // Helper for creating a compositor and setting the device scale factor.
- std::unique_ptr<aura::test::AuraTestHelper> aura_test_helper_;
-
- // Mock compositor used for getting the delegated ink points that are
- // forwarded.
- std::unique_ptr<MockCompositor> compositor_;
-};
-
-struct DelegatedInkPointTestPassToString {
- std::string operator()(
- const testing::TestParamInfo<std::tuple<TestEvent, HoveringState>> type)
- const {
- std::string suffix;
-
- if (std::get<0>(type.param) == TestEvent::kMouseEvent)
- suffix.append("Mouse");
- else
- suffix.append("Touch");
-
- if (std::get<1>(type.param) == HoveringState::kHovering)
- suffix.append("Hovering");
- else
- suffix.append("NotHovering");
-
- return suffix;
- }
-};
-
-INSTANTIATE_TEST_SUITE_P(
- DelegatedInkTrails,
- DelegatedInkPointTest,
- testing::Combine(
- testing::Values(TestEvent::kMouseEvent, TestEvent::kTouchEvent),
- testing::Values(HoveringState::kHovering, HoveringState::kNotHovering)),
- DelegatedInkPointTestPassToString());
-
-// Tests to confirm that input events are correctly forwarded to the UI
-// Compositor when DelegatedInkTrails should be drawn, and stops forwarding when
-// they no longer should be drawn.
-TEST_P(DelegatedInkPointTest, EventForwardedToCompositor) {
- // First confirm that the flag is false by default and the point is not sent.
- SendEvent(true, gfx::PointF(15, 15));
- MockDelegatedInkPointRenderer* delegated_ink_point_renderer =
- compositor()->delegated_ink_point_renderer();
-
- EXPECT_FALSE(delegated_ink_point_renderer);
-
- // Then set it to true and confirm that the DelegatedInkPointRenderer is
- // initialized, the connection is made and the point makes it to the renderer.
- SetInkMetadataFlagOnRenderFrameMetadata(true);
- gfx::DelegatedInkPoint expected_point(
- gfx::PointF(10, 10), base::TimeTicks::Now(), GetExpectedPointerId());
- SendEvent(true, expected_point.point(), expected_point.timestamp());
-
- delegated_ink_point_renderer = compositor()->delegated_ink_point_renderer();
- EXPECT_TRUE(delegated_ink_point_renderer);
- delegated_ink_point_renderer->FlushForTesting();
-
- EXPECT_TRUE(delegated_ink_point_renderer->HasDelegatedInkPoint());
- gfx::DelegatedInkPoint actual_point =
- delegated_ink_point_renderer->GetDelegatedInkPoint();
- EXPECT_EQ(expected_point.point(), actual_point.point());
- EXPECT_EQ(expected_point.timestamp(), actual_point.timestamp());
- EXPECT_EQ(GetExpectedPointerId(), actual_point.pointer_id());
-
- // Then try changing the scale factor to confirm it affects the point
- // correctly.
- const float scale = 2.6f;
- SetDeviceScaleFactor(scale);
- gfx::PointF unscaled_point(15, 15);
- base::TimeTicks unscaled_time = base::TimeTicks::Now();
-
- SendEvent(true, unscaled_point, unscaled_time);
- delegated_ink_point_renderer->FlushForTesting();
-
- unscaled_point.Scale(scale);
- expected_point = gfx::DelegatedInkPoint(unscaled_point, unscaled_time,
- GetExpectedPointerId());
-
- EXPECT_TRUE(delegated_ink_point_renderer->HasDelegatedInkPoint());
- actual_point = delegated_ink_point_renderer->GetDelegatedInkPoint();
- EXPECT_EQ(expected_point.point(), actual_point.point());
- EXPECT_EQ(expected_point.timestamp(), actual_point.timestamp());
- EXPECT_EQ(GetExpectedPointerId(), actual_point.pointer_id());
-
- // Confirm that prediction is reset when the API is no longer being used and
- // |delegated_ink_metadata| is not set.
- SetInkMetadataFlagOnRenderFrameMetadata(false);
-
- SendEvent(true, gfx::PointF(25, 25));
- delegated_ink_point_renderer->FlushForTesting();
-
- EXPECT_FALSE(delegated_ink_point_renderer->HasDelegatedInkPoint());
- EXPECT_TRUE(delegated_ink_point_renderer->GetPredictionState());
-
- // Finally, confirm that nothing is sent after the prediction has been reset
- // when the delegated ink flag on the render frame metadata is false.
- SendEvent(true, gfx::PointF(46, 46));
- delegated_ink_point_renderer->FlushForTesting();
-
- EXPECT_FALSE(delegated_ink_point_renderer->HasDelegatedInkPoint());
- EXPECT_FALSE(delegated_ink_point_renderer->GetPredictionState());
-}
-
-// Confirm that the interface is rebound if the receiver disconnects.
-TEST_P(DelegatedInkPointTest, MojoInterfaceReboundOnDisconnect) {
- // First make sure the connection exists.
- SetInkMetadataFlagOnRenderFrameMetadata(true);
- SendEvent(true, gfx::PointF(15, 15));
-
- MockDelegatedInkPointRenderer* delegated_ink_point_renderer =
- compositor()->delegated_ink_point_renderer();
-
- EXPECT_TRUE(delegated_ink_point_renderer);
- EXPECT_TRUE(delegated_ink_point_renderer->ReceiverIsBound());
-
- // Reset the receiver and flush the remote to confirm it is no longer bound.
- delegated_ink_point_renderer->ResetReceiver();
- FlushInkRenderer();
-
- EXPECT_FALSE(delegated_ink_point_renderer->ReceiverIsBound());
-
- // Confirm that it now gets reconnected correctly.
- SendEvent(true, gfx::PointF(25, 25));
-
- delegated_ink_point_renderer = compositor()->delegated_ink_point_renderer();
-
- EXPECT_TRUE(delegated_ink_point_renderer);
- EXPECT_TRUE(delegated_ink_point_renderer->ReceiverIsBound());
-}
-
-// Test to confirm that forwarding points to viz will stop and prediction is
-// reset if the state of hovering differs between what is expected and the
-// received points.
-TEST_P(DelegatedInkPointTest, StopForwardingOnHoverStateChange) {
- // First send a point and make sure it makes it to the renderer.
- SetInkMetadataFlagOnRenderFrameMetadata(true);
- SendEvent(true, gfx::PointF(15, 15));
-
- MockDelegatedInkPointRenderer* delegated_ink_point_renderer =
- compositor()->delegated_ink_point_renderer();
- EXPECT_TRUE(delegated_ink_point_renderer);
- delegated_ink_point_renderer->FlushForTesting();
-
- EXPECT_TRUE(delegated_ink_point_renderer->HasDelegatedInkPoint());
- delegated_ink_point_renderer->ClearDelegatedInkPoint();
-
- // Now send a point that doesn't match the state of hovering on the metadata
- // to confirm that it isn't sent and ResetPrediction is called.
- SendEvent(false, gfx::PointF(20, 20));
- delegated_ink_point_renderer->FlushForTesting();
-
- EXPECT_FALSE(delegated_ink_point_renderer->HasDelegatedInkPoint());
- EXPECT_TRUE(delegated_ink_point_renderer->GetPredictionState());
-
- // Send another that doesn't match to confirm the end trail point is only sent
- // once.
- SendEvent(false, gfx::PointF(25, 25));
- delegated_ink_point_renderer->FlushForTesting();
- EXPECT_FALSE(delegated_ink_point_renderer->HasDelegatedInkPoint());
-
- // Send one that does match again to confirm that points will start sending
- // again if the hovering state starts matching again.
- SendEvent(true, gfx::PointF(30, 30));
- delegated_ink_point_renderer->FlushForTesting();
-
- EXPECT_TRUE(delegated_ink_point_renderer->HasDelegatedInkPoint());
- EXPECT_FALSE(delegated_ink_point_renderer->GetPredictionState());
-}
-
-// Confirm that only move events are forwarded, not enter/exit or equivalent
-// events.
-TEST_P(DelegatedInkPointTest, IgnoreEnterAndExitEvents) {
- // First set everything up and try forwarding a point, confirming that it is
- // sent as expected.
- SetInkMetadataFlagOnRenderFrameMetadata(true);
- gfx::DelegatedInkPoint expected_point(
- gfx::PointF(10, 10), base::TimeTicks::Now(), GetExpectedPointerId());
- SendEvent(true, expected_point.point(), expected_point.timestamp());
-
- MockDelegatedInkPointRenderer* delegated_ink_point_renderer =
- compositor()->delegated_ink_point_renderer();
- EXPECT_TRUE(delegated_ink_point_renderer);
- delegated_ink_point_renderer->FlushForTesting();
-
- EXPECT_TRUE(delegated_ink_point_renderer->HasDelegatedInkPoint());
- gfx::DelegatedInkPoint actual_point =
- delegated_ink_point_renderer->GetDelegatedInkPoint();
- EXPECT_EQ(expected_point.point(), actual_point.point());
- EXPECT_EQ(expected_point.timestamp(), actual_point.timestamp());
- EXPECT_EQ(GetExpectedPointerId(), actual_point.pointer_id());
-
- // Now try with an exit event.
- SendEvent(true, gfx::PointF(42, 19), base::TimeTicks::Now(),
- /*use_enter_event=*/false, /*use_exit_event=*/true);
- delegated_ink_point_renderer->FlushForTesting();
- EXPECT_FALSE(delegated_ink_point_renderer->HasDelegatedInkPoint());
-
- // Try sending an enter event and confirm it is not forwarded.
- SendEvent(true, gfx::PointF(12, 12), base::TimeTicks::Now(),
- /*use_enter_event=*/true, /*use_exit_event=*/false);
- delegated_ink_point_renderer->FlushForTesting();
- EXPECT_FALSE(delegated_ink_point_renderer->HasDelegatedInkPoint());
-
- // Finally, confirm that sending move events will work again without issue.
- expected_point = gfx::DelegatedInkPoint(
- gfx::PointF(20, 21), base::TimeTicks::Now(), GetExpectedPointerId());
- SendEvent(true, expected_point.point(), expected_point.timestamp());
-
- delegated_ink_point_renderer->FlushForTesting();
-
- EXPECT_TRUE(delegated_ink_point_renderer->HasDelegatedInkPoint());
- actual_point = delegated_ink_point_renderer->GetDelegatedInkPoint();
- EXPECT_EQ(expected_point.point(), actual_point.point());
- EXPECT_EQ(expected_point.timestamp(), actual_point.timestamp());
- EXPECT_EQ(GetExpectedPointerId(), actual_point.pointer_id());
-}
-
-// This test confirms that points can be forwarded when using delegated ink in
-// a child frame, such as an OOPIF.
-TEST_P(DelegatedInkPointTest, ForwardPointsToChildFrame) {
- // Make the child frame, set the delegated ink flag on it, give it a
- // compositor, and set it as the hit test result so that the input router
- // sends points to it.
- ChildViewState child = MakeChildView(view_root_.get());
- SetInkMetadataFlagOnSpecificHost(true, child.widget_host.get());
- child.view->SetCompositor(compositor());
- view_root_->SetHittestResult(child.view.get(), false);
-
- // Send a point and confirm that it is forwarded, meaning that it correctly
- // checked the metadata flag on the child frame's widget.
- gfx::DelegatedInkPoint expected_point(
- gfx::PointF(10, 10), base::TimeTicks::Now(), GetExpectedPointerId());
- SendEvent(true, expected_point.point(), expected_point.timestamp(), false,
- false);
-
- MockDelegatedInkPointRenderer* delegated_ink_point_renderer =
- compositor()->delegated_ink_point_renderer();
- EXPECT_TRUE(delegated_ink_point_renderer);
- delegated_ink_point_renderer->FlushForTesting();
-
- EXPECT_TRUE(delegated_ink_point_renderer->HasDelegatedInkPoint());
- gfx::DelegatedInkPoint actual_point =
- delegated_ink_point_renderer->GetDelegatedInkPoint();
- EXPECT_EQ(expected_point.point(), actual_point.point());
- EXPECT_EQ(expected_point.timestamp(), actual_point.timestamp());
- EXPECT_EQ(GetExpectedPointerId(), actual_point.pointer_id());
-
- // Reset's the hit test result on the root so that we don't crash on
- // destruction.
- rwhier()->OnRenderWidgetHostViewBaseDestroyed(child.view.get());
-}
-
-#endif // defined(USE_AURA)
-
} // namespace content
diff --git a/content/browser/renderer_host/render_widget_host_view_aura.cc b/content/browser/renderer_host/render_widget_host_view_aura.cc
index 053eaaf..d8365d0 100644
--- a/content/browser/renderer_host/render_widget_host_view_aura.cc
+++ b/content/browser/renderer_host/render_widget_host_view_aura.cc
@@ -1855,10 +1855,10 @@
}
viz::FrameSinkId RenderWidgetHostViewAura::GetRootFrameSinkId() {
- if (!GetCompositor())
+ if (!window_ || !window_->GetHost() || !window_->GetHost()->compositor())
return viz::FrameSinkId();
- return GetCompositor()->frame_sink_id();
+ return window_->GetHost()->compositor()->frame_sink_id();
}
viz::SurfaceId RenderWidgetHostViewAura::GetCurrentSurfaceId() const {
@@ -2377,7 +2377,7 @@
UpdateLegacyWin();
#endif
- delegated_frame_host_->AttachToCompositor(GetCompositor());
+ delegated_frame_host_->AttachToCompositor(window_->GetHost()->compositor());
}
void RenderWidgetHostViewAura::RemovingFromRootWindow() {
@@ -2730,11 +2730,4 @@
tooltip_observer_for_testing_->OnTooltipTextUpdated(tooltip_text);
}
-ui::Compositor* RenderWidgetHostViewAura::GetCompositor() {
- if (!window_ || !window_->GetHost())
- return nullptr;
-
- return window_->GetHost()->compositor();
-}
-
} // namespace content
diff --git a/content/browser/renderer_host/render_widget_host_view_aura.h b/content/browser/renderer_host/render_widget_host_view_aura.h
index ea2aee1..b881bdc 100644
--- a/content/browser/renderer_host/render_widget_host_view_aura.h
+++ b/content/browser/renderer_host/render_widget_host_view_aura.h
@@ -373,8 +373,6 @@
MouseWheelPhaseHandler* GetMouseWheelPhaseHandler() override;
- ui::Compositor* GetCompositor() override;
-
protected:
~RenderWidgetHostViewAura() override;
diff --git a/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc b/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc
index a90ac41..466e96ff 100644
--- a/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc
+++ b/content/browser/renderer_host/render_widget_host_view_aura_unittest.cc
@@ -120,6 +120,7 @@
#include "ui/events/keycodes/keyboard_code_conversion.h"
#include "ui/events/test/event_generator.h"
#include "ui/gfx/geometry/rect.h"
+#include "ui/gfx/mojom/delegated_ink_point_renderer.mojom.h"
#include "ui/gfx/selection_bound.h"
#include "ui/wm/core/window_util.h"
@@ -285,6 +286,9 @@
return event_handler()->pointer_state();
}
+ // Flush the mojo remote on the event handler for testing purposes.
+ void FlushForTest() { event_handler()->FlushForTest(); }
+
void SetRenderFrameMetadata(cc::RenderFrameMetadata metadata) {
host()->render_frame_metadata_provider()->SetLastRenderFrameMetadataForTest(
metadata);
@@ -6754,4 +6758,428 @@
#endif // defined(OS_WIN)
+// Mock the DelegatedInkPointRenderer to grab the delegated ink points as they
+// are shipped off to viz from the browser process.
+class MockDelegatedInkPointRenderer
+ : public gfx::mojom::DelegatedInkPointRenderer {
+ public:
+ explicit MockDelegatedInkPointRenderer(
+ mojo::PendingReceiver<gfx::mojom::DelegatedInkPointRenderer> receiver)
+ : receiver_(this, std::move(receiver)) {}
+
+ void StoreDelegatedInkPoint(const gfx::DelegatedInkPoint& point) override {
+ delegated_ink_point_ = point;
+ }
+
+ bool HasDelegatedInkPoint() { return delegated_ink_point_.has_value(); }
+
+ gfx::DelegatedInkPoint GetDelegatedInkPoint() {
+ gfx::DelegatedInkPoint point = delegated_ink_point_.value();
+ delegated_ink_point_.reset();
+ return point;
+ }
+
+ void ClearDelegatedInkPoint() { delegated_ink_point_.reset(); }
+
+ void ResetPrediction() override { prediction_reset_ = true; }
+ bool GetPredictionState() {
+ bool state = prediction_reset_;
+ prediction_reset_ = false;
+ return state;
+ }
+
+ void FlushForTesting() { receiver_.FlushForTesting(); }
+
+ void ResetReceiver() { receiver_.reset(); }
+ bool ReceiverIsBound() { return receiver_.is_bound(); }
+
+ private:
+ mojo::Receiver<gfx::mojom::DelegatedInkPointRenderer> receiver_;
+ absl::optional<gfx::DelegatedInkPoint> delegated_ink_point_;
+ bool prediction_reset_ = false;
+};
+
+// MockCompositor class binds the mojo interfaces so that the ink points are
+// shipped to the browser process. Uses values from the real compositor to be
+// created, but a fake FrameSinkId must be used so that it hasn't already been
+// registered.
+class MockCompositor : public ui::Compositor {
+ public:
+ explicit MockCompositor(ui::Compositor* compositor)
+ : ui::Compositor(viz::FrameSinkId(5, 5),
+ compositor->context_factory(),
+ compositor->task_runner(),
+ compositor->is_pixel_canvas()) {}
+
+ void SetDelegatedInkPointRenderer(
+ mojo::PendingReceiver<gfx::mojom::DelegatedInkPointRenderer> receiver)
+ override {
+ delegated_ink_point_renderer_ =
+ std::make_unique<MockDelegatedInkPointRenderer>(std::move(receiver));
+ }
+
+ MockDelegatedInkPointRenderer* delegated_ink_point_renderer() {
+ return delegated_ink_point_renderer_.get();
+ }
+
+ private:
+ std::unique_ptr<MockDelegatedInkPointRenderer> delegated_ink_point_renderer_;
+};
+
+enum TestEvent { kMouseEvent, kTouchEvent };
+enum HoveringState { kHovering, kNotHovering };
+
+class DelegatedInkPointTest
+ : public RenderWidgetHostViewAuraTest,
+ public testing::WithParamInterface<std::tuple<TestEvent, HoveringState>> {
+ public:
+ DelegatedInkPointTest() = default;
+
+ void SetUp() override {
+ RenderWidgetHostViewAuraTest::SetUp();
+
+ InitViewForFrame(nullptr);
+ aura_test_helper_->GetTestScreen()->SetDeviceScaleFactor(1.0f);
+
+ real_compositor_ = view_->GetNativeView()->layer()->GetCompositor();
+ compositor_ = std::make_unique<MockCompositor>(
+ aura_test_helper_->GetHost()->compositor());
+ view_->GetNativeView()->layer()->SetCompositorForTesting(compositor_.get());
+ }
+
+ void TearDown() override {
+ // Restore the view's compositor to the old value so it no longer references
+ // the MockCompositor that is about to be destructed. This also ensures
+ // that the view can be properly destroyed by TearDown().
+ view_->GetNativeView()->layer()->SetCompositorForTesting(real_compositor_);
+ compositor_.reset();
+ RenderWidgetHostViewAuraTest::TearDown();
+ }
+
+ TestEvent GetEventParam() { return std::get<0>(GetParam()); }
+ HoveringState GetHoverParam() { return std::get<1>(GetParam()); }
+
+ void SetInkMetadataFlagOnRenderFrameMetadata(bool delegated_ink) {
+ cc::RenderFrameMetadata metadata;
+ if (delegated_ink) {
+ metadata.delegated_ink_metadata = cc::DelegatedInkBrowserMetadata(
+ GetHoverParam() == HoveringState::kHovering);
+ }
+ view_->SetRenderFrameMetadata(metadata);
+ }
+
+ void SendEvent(bool match_test_hovering_state,
+ gfx::PointF point,
+ base::TimeTicks timestamp = ui::EventTimeForNow()) {
+ SendEvent(match_test_hovering_state, point, timestamp,
+ /*use_enter_event*/ false, /*use_exit_event*/ false);
+ }
+
+ void SendEvent(bool match_test_hovering_state,
+ const gfx::PointF& point,
+ base::TimeTicks timestamp,
+ bool use_enter_event,
+ bool use_exit_event) {
+ DCHECK(!(use_enter_event && use_exit_event));
+
+ // Hovering creates and sends ui::MouseEvents with
+ // ET_MOUSE_{MOVED,ENTERED,EXITED} types, so do the same here in hovering
+ // scenarios.
+ if (GetEventParam() == TestEvent::kTouchEvent &&
+ !Hovering(match_test_hovering_state)) {
+ ui::EventType event_type = ui::ET_TOUCH_MOVED;
+ if (use_enter_event)
+ event_type = ui::ET_TOUCH_PRESSED;
+ if (use_exit_event)
+ event_type = ui::ET_TOUCH_RELEASED;
+
+ // Touch needs a pressed event first to properly handle future move
+ // events.
+ SendTouchPress(point);
+
+ ui::TouchEvent touch_event(
+ event_type, point, point, timestamp,
+ ui::PointerDetails(ui::EventPointerType::kTouch, kPointerId));
+ view_->OnTouchEvent(&touch_event);
+
+ // Need to send a new press event after ending the previous touch.
+ if (use_exit_event)
+ sent_touch_press_ = false;
+ } else {
+ ui::EventPointerType pointer_type = ui::EventPointerType::kMouse;
+ if (GetEventParam() == TestEvent::kTouchEvent) {
+ DCHECK(Hovering(match_test_hovering_state));
+ pointer_type = ui::EventPointerType::kPen;
+ }
+
+ ui::EventType event_type = ui::ET_MOUSE_MOVED;
+ if (use_enter_event)
+ event_type = ui::ET_MOUSE_ENTERED;
+ if (use_exit_event)
+ event_type = ui::ET_MOUSE_EXITED;
+
+ int flags =
+ Hovering(match_test_hovering_state) ? 0 : ui::EF_LEFT_MOUSE_BUTTON;
+ ui::MouseEvent mouse_event(event_type, point, point, timestamp, flags, 0,
+ ui::PointerDetails(pointer_type, kPointerId));
+ view_->OnMouseEvent(&mouse_event);
+ }
+ }
+
+ MockCompositor* compositor() { return compositor_.get(); }
+
+ int32_t GetExpectedPointerId() const { return kPointerId; }
+
+ private:
+ void SendTouchPress(const gfx::PointF& requested_touch_location) {
+ DCHECK(GetEventParam() == TestEvent::kTouchEvent);
+ if (sent_touch_press_)
+ return;
+
+ // Location of the press event doesn't matter, so long as it doesn't exactly
+ // match the location of the subsequent move event. If they match, then the
+ // move event is dropped.
+ gfx::PointF point(requested_touch_location.x() + 2.f,
+ requested_touch_location.y() + 2.f);
+
+ ui::TouchEvent press(
+ ui::ET_TOUCH_PRESSED, point, point, ui::EventTimeForNow(),
+ ui::PointerDetails(ui::EventPointerType::kTouch, kPointerId));
+
+ view_->OnTouchEvent(&press);
+ sent_touch_press_ = true;
+ }
+
+ bool Hovering(bool match_test_hovering_state) {
+ return (GetHoverParam() == HoveringState::kHovering &&
+ match_test_hovering_state) ||
+ (GetHoverParam() == HoveringState::kNotHovering &&
+ !match_test_hovering_state);
+ }
+
+ // Pointer id to use in these tests. It must be consistent throughout a single
+ // test for some of the touch variations.
+ const int32_t kPointerId = 5;
+
+ // Touch events are ignored if a press isn't sent first, so use this to track
+ // if we have already sent a touch press event yet or not.
+ bool sent_touch_press_ = false;
+
+ // The real compositor that was contained by the |view_| and must be replaced
+ // before tear down, and the mock compositor used for getting the delegated
+ // ink points.
+ ui::Compositor* real_compositor_;
+ std::unique_ptr<MockCompositor> compositor_;
+};
+
+struct DelegatedInkPointTestPassToString {
+ std::string operator()(
+ const testing::TestParamInfo<std::tuple<TestEvent, HoveringState>> type)
+ const {
+ std::string suffix;
+
+ if (std::get<0>(type.param) == TestEvent::kMouseEvent)
+ suffix.append("Mouse");
+ else
+ suffix.append("Touch");
+
+ if (std::get<1>(type.param) == HoveringState::kHovering)
+ suffix.append("Hovering");
+ else
+ suffix.append("NotHovering");
+
+ return suffix;
+ }
+};
+
+INSTANTIATE_TEST_SUITE_P(
+ DelegatedInkTrails,
+ DelegatedInkPointTest,
+ testing::Combine(
+ testing::Values(TestEvent::kMouseEvent, TestEvent::kTouchEvent),
+ testing::Values(HoveringState::kHovering, HoveringState::kNotHovering)),
+ DelegatedInkPointTestPassToString());
+
+// Tests to confirm that input events are correctly forwarded to the UI
+// Compositor when DelegatedInkTrails should be drawn, and stops forwarding when
+// they no longer should be drawn.
+TEST_P(DelegatedInkPointTest, EventForwardedToCompositor) {
+ // First confirm that the flag is false by default and the point is not sent.
+ SendEvent(true, gfx::PointF(15, 15));
+ MockDelegatedInkPointRenderer* delegated_ink_point_renderer =
+ compositor()->delegated_ink_point_renderer();
+
+ EXPECT_FALSE(delegated_ink_point_renderer);
+
+ // Then set it to true and confirm that the DelegatedInkPointRenderer is
+ // initialized, the connection is made and the point makes it to the renderer.
+ SetInkMetadataFlagOnRenderFrameMetadata(true);
+ gfx::DelegatedInkPoint expected_point(
+ gfx::PointF(10, 10), base::TimeTicks::Now(), GetExpectedPointerId());
+ SendEvent(true, expected_point.point(), expected_point.timestamp());
+
+ delegated_ink_point_renderer = compositor()->delegated_ink_point_renderer();
+ EXPECT_TRUE(delegated_ink_point_renderer);
+ delegated_ink_point_renderer->FlushForTesting();
+
+ EXPECT_TRUE(delegated_ink_point_renderer->HasDelegatedInkPoint());
+ gfx::DelegatedInkPoint actual_point =
+ delegated_ink_point_renderer->GetDelegatedInkPoint();
+ EXPECT_EQ(expected_point.point(), actual_point.point());
+ EXPECT_EQ(expected_point.timestamp(), actual_point.timestamp());
+ EXPECT_EQ(GetExpectedPointerId(), actual_point.pointer_id());
+
+ // Then try changing the scale factor to confirm it affects the point
+ // correctly.
+ const float scale = 2.6f;
+ aura_test_helper_->GetTestScreen()->SetDeviceScaleFactor(scale);
+ gfx::PointF unscaled_point(15, 15);
+ base::TimeTicks unscaled_time = base::TimeTicks::Now();
+
+ SendEvent(true, unscaled_point, unscaled_time);
+ delegated_ink_point_renderer->FlushForTesting();
+
+ unscaled_point.Scale(scale);
+ expected_point = gfx::DelegatedInkPoint(unscaled_point, unscaled_time,
+ GetExpectedPointerId());
+
+ EXPECT_TRUE(delegated_ink_point_renderer->HasDelegatedInkPoint());
+ actual_point = delegated_ink_point_renderer->GetDelegatedInkPoint();
+ EXPECT_EQ(expected_point.point(), actual_point.point());
+ EXPECT_EQ(expected_point.timestamp(), actual_point.timestamp());
+ EXPECT_EQ(GetExpectedPointerId(), actual_point.pointer_id());
+
+ // Confirm that prediction is reset when the API is no longer being used and
+ // |delegated_ink_metadata| is not set.
+ SetInkMetadataFlagOnRenderFrameMetadata(false);
+
+ SendEvent(true, gfx::PointF(25, 25));
+ delegated_ink_point_renderer->FlushForTesting();
+
+ EXPECT_FALSE(delegated_ink_point_renderer->HasDelegatedInkPoint());
+ EXPECT_TRUE(delegated_ink_point_renderer->GetPredictionState());
+
+ // Finally, confirm that nothing is sent after the prediction has been reset
+ // when the delegated ink flag on the render frame metadata is false.
+ SendEvent(true, gfx::PointF(46, 46));
+ delegated_ink_point_renderer->FlushForTesting();
+
+ EXPECT_FALSE(delegated_ink_point_renderer->HasDelegatedInkPoint());
+ EXPECT_FALSE(delegated_ink_point_renderer->GetPredictionState());
+}
+
+// Confirm that the interface is rebound if the receiver disconnects.
+TEST_P(DelegatedInkPointTest, MojoInterfaceReboundOnDisconnect) {
+ // First make sure the connection exists.
+ SetInkMetadataFlagOnRenderFrameMetadata(true);
+ SendEvent(true, gfx::PointF(15, 15));
+
+ MockDelegatedInkPointRenderer* delegated_ink_point_renderer =
+ compositor()->delegated_ink_point_renderer();
+
+ EXPECT_TRUE(delegated_ink_point_renderer);
+ EXPECT_TRUE(delegated_ink_point_renderer->ReceiverIsBound());
+
+ // Reset the receiver and flush the remote to confirm it is no longer bound.
+ delegated_ink_point_renderer->ResetReceiver();
+ view_->FlushForTest();
+
+ EXPECT_FALSE(delegated_ink_point_renderer->ReceiverIsBound());
+
+ // Confirm that it now gets reconnected correctly.
+ SendEvent(true, gfx::PointF(25, 25));
+
+ delegated_ink_point_renderer = compositor()->delegated_ink_point_renderer();
+
+ EXPECT_TRUE(delegated_ink_point_renderer);
+ EXPECT_TRUE(delegated_ink_point_renderer->ReceiverIsBound());
+}
+
+// Test to confirm that forwarding points to viz will stop and prediction is
+// reset if the state of hovering differs between what is expected and the
+// received points.
+TEST_P(DelegatedInkPointTest, StopForwardingOnHoverStateChange) {
+ // First send a point and make sure it makes it to the renderer.
+ SetInkMetadataFlagOnRenderFrameMetadata(true);
+ SendEvent(true, gfx::PointF(15, 15));
+
+ MockDelegatedInkPointRenderer* delegated_ink_point_renderer =
+ compositor()->delegated_ink_point_renderer();
+ EXPECT_TRUE(delegated_ink_point_renderer);
+ delegated_ink_point_renderer->FlushForTesting();
+
+ EXPECT_TRUE(delegated_ink_point_renderer->HasDelegatedInkPoint());
+ delegated_ink_point_renderer->ClearDelegatedInkPoint();
+
+ // Now send a point that doesn't match the state of hovering on the metadata
+ // to confirm that it isn't sent and ResetPrediction is called.
+ SendEvent(false, gfx::PointF(20, 20));
+ delegated_ink_point_renderer->FlushForTesting();
+
+ EXPECT_FALSE(delegated_ink_point_renderer->HasDelegatedInkPoint());
+ EXPECT_TRUE(delegated_ink_point_renderer->GetPredictionState());
+
+ // Send another that doesn't match to confirm the end trail point is only sent
+ // once.
+ SendEvent(false, gfx::PointF(25, 25));
+ delegated_ink_point_renderer->FlushForTesting();
+ EXPECT_FALSE(delegated_ink_point_renderer->HasDelegatedInkPoint());
+
+ // Send one that does match again to confirm that points will start sending
+ // again if the hovering state starts matching again.
+ SendEvent(true, gfx::PointF(30, 30));
+ delegated_ink_point_renderer->FlushForTesting();
+
+ EXPECT_TRUE(delegated_ink_point_renderer->HasDelegatedInkPoint());
+ EXPECT_FALSE(delegated_ink_point_renderer->GetPredictionState());
+}
+
+// Confirm that only move events are forwarded, not enter/exit or equivalent
+// events.
+TEST_P(DelegatedInkPointTest, IgnoreEnterAndExitEvents) {
+ // First set everything up and try forwarding a point, confirming that it is
+ // sent as expected.
+ SetInkMetadataFlagOnRenderFrameMetadata(true);
+ gfx::DelegatedInkPoint expected_point(
+ gfx::PointF(10, 10), base::TimeTicks::Now(), GetExpectedPointerId());
+ SendEvent(true, expected_point.point(), expected_point.timestamp());
+
+ MockDelegatedInkPointRenderer* delegated_ink_point_renderer =
+ compositor()->delegated_ink_point_renderer();
+ EXPECT_TRUE(delegated_ink_point_renderer);
+ delegated_ink_point_renderer->FlushForTesting();
+
+ EXPECT_TRUE(delegated_ink_point_renderer->HasDelegatedInkPoint());
+ gfx::DelegatedInkPoint actual_point =
+ delegated_ink_point_renderer->GetDelegatedInkPoint();
+ EXPECT_EQ(expected_point.point(), actual_point.point());
+ EXPECT_EQ(expected_point.timestamp(), actual_point.timestamp());
+ EXPECT_EQ(GetExpectedPointerId(), actual_point.pointer_id());
+
+ // Try sending an enter event and confirm it is not forwarded.
+ SendEvent(true, gfx::PointF(12, 12), base::TimeTicks::Now(),
+ /*use_enter_event*/ true, /*use_exit_event*/ false);
+ delegated_ink_point_renderer->FlushForTesting();
+ EXPECT_FALSE(delegated_ink_point_renderer->HasDelegatedInkPoint());
+
+ // Now try with an exit event.
+ SendEvent(true, gfx::PointF(42, 19), base::TimeTicks::Now(),
+ /*use_enter_event*/ false, /*use_exit_event*/ true);
+ delegated_ink_point_renderer->FlushForTesting();
+ EXPECT_FALSE(delegated_ink_point_renderer->HasDelegatedInkPoint());
+
+ // Finally, confirm that sending move events will work again without issue.
+ expected_point = gfx::DelegatedInkPoint(
+ gfx::PointF(20, 21), base::TimeTicks::Now(), GetExpectedPointerId());
+ SendEvent(true, expected_point.point(), expected_point.timestamp());
+
+ delegated_ink_point_renderer->FlushForTesting();
+
+ EXPECT_TRUE(delegated_ink_point_renderer->HasDelegatedInkPoint());
+ actual_point = delegated_ink_point_renderer->GetDelegatedInkPoint();
+ EXPECT_EQ(expected_point.point(), actual_point.point());
+ EXPECT_EQ(expected_point.timestamp(), actual_point.timestamp());
+ EXPECT_EQ(GetExpectedPointerId(), actual_point.pointer_id());
+}
+
} // namespace content
diff --git a/content/browser/renderer_host/render_widget_host_view_base.cc b/content/browser/renderer_host/render_widget_host_view_base.cc
index 3e66a34e..ec0d6b0 100644
--- a/content/browser/renderer_host/render_widget_host_view_base.cc
+++ b/content/browser/renderer_host/render_widget_host_view_base.cc
@@ -988,8 +988,4 @@
transformed_point);
}
-ui::Compositor* RenderWidgetHostViewBase::GetCompositor() {
- return nullptr;
-}
-
} // namespace content
diff --git a/content/browser/renderer_host/render_widget_host_view_base.h b/content/browser/renderer_host/render_widget_host_view_base.h
index 6c9aa1e..9e207025 100644
--- a/content/browser/renderer_host/render_widget_host_view_base.h
+++ b/content/browser/renderer_host/render_widget_host_view_base.h
@@ -54,7 +54,6 @@
}
namespace ui {
-class Compositor;
enum class DomCode;
class LatencyInfo;
class TouchEvent;
@@ -545,8 +544,6 @@
void SetTooltipObserverForTesting(TooltipObserver* observer);
- virtual ui::Compositor* GetCompositor();
-
protected:
explicit RenderWidgetHostViewBase(RenderWidgetHost* host);
~RenderWidgetHostViewBase() override;
diff --git a/content/browser/renderer_host/render_widget_host_view_child_frame.cc b/content/browser/renderer_host/render_widget_host_view_child_frame.cc
index 4e26cd2ff..14a83f94 100644
--- a/content/browser/renderer_host/render_widget_host_view_child_frame.cc
+++ b/content/browser/renderer_host/render_widget_host_view_child_frame.cc
@@ -1003,10 +1003,4 @@
host()->SynchronizeVisualProperties();
}
-ui::Compositor* RenderWidgetHostViewChildFrame::GetCompositor() {
- if (!GetRootView())
- return nullptr;
- return GetRootView()->GetCompositor();
-}
-
} // namespace content
diff --git a/content/browser/renderer_host/render_widget_host_view_child_frame.h b/content/browser/renderer_host/render_widget_host_view_child_frame.h
index fdcd303..a32e3e0 100644
--- a/content/browser/renderer_host/render_widget_host_view_child_frame.h
+++ b/content/browser/renderer_host/render_widget_host_view_child_frame.h
@@ -256,8 +256,6 @@
return weak_factory_.GetWeakPtr();
}
- ui::Compositor* GetCompositor() override;
-
protected:
~RenderWidgetHostViewChildFrame() override;
diff --git a/content/browser/renderer_host/render_widget_host_view_event_handler.cc b/content/browser/renderer_host/render_widget_host_view_event_handler.cc
index 68ba083..f4dbe7b3e 100644
--- a/content/browser/renderer_host/render_widget_host_view_event_handler.cc
+++ b/content/browser/renderer_host/render_widget_host_view_event_handler.cc
@@ -364,6 +364,69 @@
}
}
+bool IsMoveEvent(ui::EventType type) {
+ return type == ui::ET_MOUSE_MOVED || type == ui::ET_MOUSE_DRAGGED ||
+ type == ui::ET_TOUCH_MOVED;
+}
+
+void RenderWidgetHostViewEventHandler::ForwardDelegatedInkPoint(
+ ui::LocatedEvent* event,
+ bool hovering,
+ int32_t pointer_id) {
+ const cc::RenderFrameMetadata& last_metadata =
+ host_->render_frame_metadata_provider()->LastRenderFrameMetadata();
+ if (IsMoveEvent(event->type()) &&
+ last_metadata.delegated_ink_metadata.has_value() &&
+ hovering == last_metadata.delegated_ink_metadata.value()
+ .delegated_ink_is_hovering) {
+ if (!delegated_ink_point_renderer_.is_bound()) {
+ ui::Compositor* compositor = window_ && window_->layer()
+ ? window_->layer()->GetCompositor()
+ : nullptr;
+
+ // The remote can't be bound if the compositor is null, so bail if that
+ // is the case so we don't crash by trying to use an unbound remote.
+ if (!compositor)
+ return;
+
+ TRACE_EVENT_INSTANT0("input",
+ "Binding mojo interface for delegated ink points.",
+ TRACE_EVENT_SCOPE_THREAD);
+ compositor->SetDelegatedInkPointRenderer(
+ delegated_ink_point_renderer_.BindNewPipeAndPassReceiver());
+ delegated_ink_point_renderer_.reset_on_disconnect();
+ }
+
+ gfx::PointF point = event->root_location_f();
+ point.Scale(host_view_->GetDeviceScaleFactor());
+ gfx::DelegatedInkPoint delegated_ink_point(point, event->time_stamp(),
+ pointer_id);
+ TRACE_EVENT_INSTANT1("input",
+ "Forwarding delegated ink point from browser.",
+ TRACE_EVENT_SCOPE_THREAD, "delegated point",
+ delegated_ink_point.ToString());
+
+ // Calling this will result in IPC calls to get |delegated_ink_point| to
+ // viz. The decision to do this here was made with the understanding that
+ // the IPC overhead will result in a minor increase in latency for getting
+ // this event to the renderer. However, by sending it here, the event is
+ // given the greatest possible chance to make it to viz before
+ // DrawAndSwap() is called, allowing more points to be drawn as part of
+ // the delegated ink trail, and thus reducing user perceived latency.
+ delegated_ink_point_renderer_->StoreDelegatedInkPoint(delegated_ink_point);
+ ended_delegated_ink_trail_ = false;
+ } else if (delegated_ink_point_renderer_.is_bound() &&
+ !ended_delegated_ink_trail_) {
+ // Let viz know that the most recent point it received from us is probably
+ // the last point the user is inking, so it shouldn't predict anything
+ // beyond it.
+ TRACE_EVENT_INSTANT0("input", "Delegated ink trail ended",
+ TRACE_EVENT_SCOPE_THREAD);
+ delegated_ink_point_renderer_->ResetPrediction();
+ ended_delegated_ink_trail_ = true;
+ }
+}
+
void RenderWidgetHostViewEventHandler::OnMouseEvent(ui::MouseEvent* event) {
TRACE_EVENT0("input", "RenderWidgetHostViewBase::OnMouseEvent");
@@ -407,6 +470,9 @@
bool is_selection_popup = NeedsInputGrab(popup_child_host_view_);
if (CanRendererHandleEvent(event, mouse_locked_, is_selection_popup) &&
!(event->flags() & ui::EF_FROM_TOUCH)) {
+ bool hovering = (event->type() ^ ui::ET_MOUSE_DRAGGED) &&
+ (event->type() ^ ui::ET_MOUSE_PRESSED);
+ ForwardDelegatedInkPoint(event, hovering, event->pointer_details().id);
// Confirm existing composition text on mouse press, to make sure
// the input caret won't be moved with an ongoing composition text.
@@ -531,6 +597,9 @@
if (handled)
return;
+ ForwardDelegatedInkPoint(event, event->hovering(),
+ event->pointer_details().id);
+
if (had_no_pointer)
delegate_->selection_controller_client()->OnTouchDown();
if (!pointer_state_.GetPointerCount())
diff --git a/content/browser/renderer_host/render_widget_host_view_event_handler.h b/content/browser/renderer_host/render_widget_host_view_event_handler.h
index 6d41f4d..65dbc6313 100644
--- a/content/browser/renderer_host/render_widget_host_view_event_handler.h
+++ b/content/browser/renderer_host/render_widget_host_view_event_handler.h
@@ -12,12 +12,14 @@
#include "content/browser/renderer_host/input/mouse_wheel_phase_handler.h"
#include "content/common/content_export.h"
#include "content/public/browser/native_web_keyboard_event.h"
+#include "mojo/public/cpp/bindings/remote.h"
#include "third_party/abseil-cpp/absl/types/optional.h"
#include "third_party/blink/public/mojom/input/pointer_lock_result.mojom.h"
#include "ui/aura/scoped_enable_unadjusted_mouse_events.h"
#include "ui/aura/scoped_keyboard_hook.h"
#include "ui/events/event_handler.h"
#include "ui/events/gestures/motion_event_aura.h"
+#include "ui/gfx/mojom/delegated_ink_point_renderer.mojom.h"
#include "ui/latency/latency_info.h"
namespace aura {
@@ -252,6 +254,15 @@
void HandleMouseWheelEvent(ui::MouseEvent* event);
+ // Forward the location and timestamp of the event to viz if a delegated ink
+ // trail is requested.
+ void ForwardDelegatedInkPoint(ui::LocatedEvent* event,
+ bool hovering,
+ int32_t pointer_id);
+
+ // Flush the remote for testing purposes.
+ void FlushForTest() { delegated_ink_point_renderer_.FlushForTesting(); }
+
// Whether return characters should be passed on to the RenderWidgetHostImpl.
bool accept_return_character_ = false;
@@ -314,6 +325,18 @@
std::unique_ptr<HitTestDebugKeyEventObserver> debug_observer_;
+ // Remote end of the connection for sending delegated ink points to viz to
+ // support the delegated ink trails feature.
+ mojo::Remote<gfx::mojom::DelegatedInkPointRenderer>
+ delegated_ink_point_renderer_;
+ // Used to know if we have already told viz to reset prediction because the
+ // final point of the delegated ink trail has been sent. True when prediction
+ // has already been reset for the most recent trail, false otherwise. This
+ // flag helps make sure that we don't send more IPCs than necessary to viz to
+ // reset prediction. Sending extra IPCs wouldn't impact correctness, but can
+ // impact performance due to the IPC overhead.
+ bool ended_delegated_ink_trail_ = false;
+
DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewEventHandler);
};
diff --git a/content/browser/site_per_process_hit_test_browsertest.cc b/content/browser/site_per_process_hit_test_browsertest.cc
index 556a1838..05e9add2 100644
--- a/content/browser/site_per_process_hit_test_browsertest.cc
+++ b/content/browser/site_per_process_hit_test_browsertest.cc
@@ -18,7 +18,6 @@
#include "base/test/scoped_feature_list.h"
#include "base/test/test_timeouts.h"
#include "build/build_config.h"
-#include "components/viz/common/features.h"
#include "components/viz/test/host_frame_sink_manager_test_api.h"
#include "content/browser/compositor/surface_utils.h"
#include "content/browser/renderer_host/cursor_manager.h"
@@ -7329,130 +7328,4 @@
EXPECT_EQ(kSlowHitTestFlags, hit_test_data[2].flags);
}
-#if defined(USE_AURA)
-class SitePerProcessDelegatedInkBrowserTest
- : public SitePerProcessHitTestBrowserTest {
- public:
- SitePerProcessDelegatedInkBrowserTest() = default;
-
- void SetUpCommandLine(base::CommandLine* command_line) override {
- SitePerProcessHitTestBrowserTest::SetUpCommandLine(command_line);
- command_line->AppendSwitchASCII(switches::kEnableBlinkFeatures,
- "DelegatedInkTrails");
- }
-};
-
-// Test confirms that a point hitting an OOPIF that is requesting delegated ink
-// trails results in the metadata being correctly sent to the child's
-// RenderWidgetHost and is usable for sending delegated ink points.
-IN_PROC_BROWSER_TEST_F(SitePerProcessDelegatedInkBrowserTest,
- MetadataAndPointGoThroughOOPIF) {
- // Delegated ink is only supported on Skia Renderer for now.
- if (!features::IsUsingSkiaRenderer())
- return;
-
- GURL main_url(embedded_test_server()->GetURL(
- "/frame_tree/page_with_positioned_frame.html"));
- EXPECT_TRUE(NavigateToURL(shell(), main_url));
-
- FrameTreeNode* root = static_cast<WebContentsImpl*>(shell()->web_contents())
- ->GetFrameTree()
- ->root();
- ASSERT_EQ(1U, root->child_count());
-
- FrameTreeNode* child = root->child_at(0);
-
- GURL site_url(embedded_test_server()->GetURL("baz.com", "/title1.html"));
- EXPECT_EQ(site_url, child->current_url());
- EXPECT_NE(shell()->web_contents()->GetSiteInstance(),
- child->current_frame_host()->GetSiteInstance());
-
- // Make sure the child frame is indeed a OOPIF
- EXPECT_TRUE(child->current_frame_host()->IsCrossProcessSubframe());
-
- EXPECT_TRUE(ExecJs(child->current_frame_host(), R"(
- let presenter = null;
- navigator.ink.requestPresenter('delegated-ink-trail').then(e => {
- presenter = e;
- });
- let style = { color: 'green', diameter: 21 };
-
- window.addEventListener('pointermove' , evt => {
- presenter.updateInkTrailStartPoint(evt, style);
- document.write('Force a new frame so that an updated ' +
- 'RenderFrameMetadata is sent to the browser process.');
- });
- )"));
-
- RenderWidgetHostImpl* root_rwh =
- root->current_frame_host()->GetRenderWidgetHost();
- RenderWidgetHostImpl* child_rwh =
- child->current_frame_host()->GetRenderWidgetHost();
-
- // Create listeners for mouse events.
- RenderWidgetHostMouseEventMonitor main_frame_monitor(root_rwh);
- RenderWidgetHostMouseEventMonitor child_frame_monitor(child_rwh);
-
- WaitForHitTestData(child->current_frame_host());
-
- RenderWidgetHostViewBase* root_view =
- static_cast<RenderWidgetHostViewBase*>(root_rwh->GetView());
- RenderWidgetHostViewBase* rwhv_child =
- static_cast<RenderWidgetHostViewBase*>(child_rwh->GetView());
-
- RenderWidgetHostInputEventRouter* router =
- web_contents()->GetInputEventRouter();
-
- EXPECT_FALSE(router->IsDelegatedInkRendererBoundForTest());
-
- // Target MouseMove to child frame.
- blink::WebMouseEvent mouse_event(
- blink::WebInputEvent::Type::kMouseMove,
- blink::WebInputEvent::kNoModifiers,
- blink::WebInputEvent::GetStaticTimeStampForTests());
- SetWebEventPositions(&mouse_event, gfx::Point(55, 55), root_view);
-
- RouteMouseEventAndWaitUntilDispatch(router, root_view, rwhv_child,
- &mouse_event);
-
- // Dispatch twice because the router generates an extra MouseLeave for the
- // main frame.
- main_frame_monitor.ResetEventReceived();
- child_frame_monitor.ResetEventReceived();
-
- RouteMouseEventAndWaitUntilDispatch(router, root_view, rwhv_child,
- &mouse_event);
- EXPECT_FALSE(main_frame_monitor.EventWasReceived());
- EXPECT_TRUE(child_frame_monitor.EventWasReceived());
-
- // Wait for the child to receive and process input so that the new
- // RenderFrameMetadata is sent to the browser process.
- {
- auto observer = std::make_unique<MainThreadFrameObserver>(child_rwh);
- observer->Wait();
- }
-
- // Confirm that the metadata is what we expect and accessible from the child's
- // RenderWidgetHost.
- const cc::RenderFrameMetadata& last_metadata =
- child_rwh->render_frame_metadata_provider()->LastRenderFrameMetadata();
- EXPECT_TRUE(last_metadata.delegated_ink_metadata.has_value());
- EXPECT_TRUE(
- last_metadata.delegated_ink_metadata.value().delegated_ink_is_hovering);
-
- // Send one more mouse move event and confirm that it causes the forwarding
- // to occur, which will result in the |delegated_ink_point_renderer_| mojom
- // remote being bound.
- main_frame_monitor.ResetEventReceived();
- child_frame_monitor.ResetEventReceived();
- SetWebEventPositions(&mouse_event, gfx::Point(57, 57), root_view);
- RouteMouseEventAndWaitUntilDispatch(router, root_view, rwhv_child,
- &mouse_event);
-
- EXPECT_FALSE(main_frame_monitor.EventWasReceived());
- EXPECT_TRUE(child_frame_monitor.EventWasReceived());
- EXPECT_TRUE(router->IsDelegatedInkRendererBoundForTest());
-}
-#endif // USE_AURA
-
} // namespace content
diff --git a/content/test/test_render_view_host.cc b/content/test/test_render_view_host.cc
index cea0a32..88bd15d 100644
--- a/content/test/test_render_view_host.cc
+++ b/content/test/test_render_view_host.cc
@@ -234,10 +234,6 @@
return display_feature_;
}
-ui::Compositor* TestRenderWidgetHostView::GetCompositor() {
- return compositor_;
-}
-
TestRenderViewHost::TestRenderViewHost(
FrameTree* frame_tree,
SiteInstance* instance,
diff --git a/content/test/test_render_view_host.h b/content/test/test_render_view_host.h
index 0529c4ec..5482020 100644
--- a/content/test/test_render_view_host.h
+++ b/content/test/test_render_view_host.h
@@ -118,7 +118,6 @@
viz::SurfaceId GetCurrentSurfaceId() const override;
std::unique_ptr<SyntheticGestureTarget> CreateSyntheticGestureTarget()
override;
- ui::Compositor* GetCompositor() override;
bool is_showing() const { return is_showing_; }
bool is_occluded() const { return is_occluded_; }
@@ -130,8 +129,6 @@
const WebCursor& last_cursor() const { return last_cursor_; }
- void SetCompositor(ui::Compositor* compositor) { compositor_ = compositor; }
-
protected:
// RenderWidgetHostViewBase:
void UpdateBackgroundColor() override;
@@ -157,8 +154,6 @@
#endif
absl::optional<DisplayFeature> display_feature_;
-
- ui::Compositor* compositor_ = nullptr;
};
// TestRenderViewHost ----------------------------------------------------------
