Set flag on browser process to begin supporting delegated ink trails

In order to start having the browser process forward ink points to
viz for delegated ink trails, add a flag onto the RenderFrameMetadata
that lets the browser process know it should start.
RenderFrameMetadataObserver will pick it up and ship it over to the
browser process, where it will be picked up by RenderWidgetHostViewBase
and saved for a future CL, where RWHVEventHandler will use it.

Bug: 1052145
Change-Id: I8305292de6289dcec3fb4083666898161ae1dc41
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2240356Reviewed-by: Jonathan Ross <jonross@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Reviewed-by: Ken Buchanan <kenrb@chromium.org>
Reviewed-by: David Bokan <bokan@chromium.org>
Reviewed-by: Daniel Libby <dlibby@microsoft.com>
Commit-Queue: Mario Bianucci <mabian@microsoft.com>
Cr-Commit-Position: refs/heads/master@{#780091}

cc/trees/layer_tree_host_impl.cc

@@ -2518,6 +2518,8 @@ viz::CompositorFrame LayerTreeHostImpl::GenerateCompositorFrame(
 
   if (render_frame_metadata_observer_) {
     last_draw_render_frame_metadata_ = MakeRenderFrameMetadata(frame);
+    last_draw_render_frame_metadata_->has_delegated_ink_metadata =
+        metadata.delegated_ink_metadata.get();
 
     // We cache the value of any new vertical scroll direction so that we can
     // accurately determine when the next change in vertical scroll direction

cc/trees/layer_tree_host_unittest.cc

@@ -8914,5 +8914,112 @@ class LayerTreeHostCustomThrougputTrackerTest : public LayerTreeHostTest {
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostCustomThrougputTrackerTest);
 
+// Confirm that DelegatedInkMetadata set on the LTH propagates to the
+// CompositorFrameMetadata and RenderFrameMetadata, and then both are correctly
+// reset when another frame is drawn without DelegatedInkMetadata.
+class LayerTreeHostTestDelegatedInkMetadataOnAndOff
+    : public LayerTreeHostTest,
+      public RenderFrameMetadataObserver {
+ public:
+  // Provides a wrapper which can be passed to LayerTreeHost, but just forwards
+  // to the test class.
+  class ForwardingRenderFrameMetadataObserver
+      : public RenderFrameMetadataObserver {
+   public:
+    explicit ForwardingRenderFrameMetadataObserver(
+        RenderFrameMetadataObserver* target)
+        : target_(target) {}
+
+    // RenderFrameMetadataObserver implementation.
+    void BindToCurrentThread() override { target_->BindToCurrentThread(); }
+    void OnRenderFrameSubmission(
+        const RenderFrameMetadata& render_frame_metadata,
+        viz::CompositorFrameMetadata* compositor_frame_metadata,
+        bool force_send) override {
+      target_->OnRenderFrameSubmission(render_frame_metadata,
+                                       compositor_frame_metadata, force_send);
+    }
+
+   private:
+    RenderFrameMetadataObserver* target_ = nullptr;
+  };
+
+  void BeginTest() override {
+    // Set up a basic render frame observer for the LTH/LTHI to forward to.
+    layer_tree_host()->SetRenderFrameObserver(
+        std::make_unique<ForwardingRenderFrameMetadataObserver>(this));
+
+    // Setting up a basic frame that can be redrawn.
+    layer_tree_host()->SetViewportRectAndScale(gfx::Rect(10, 10), 1.f,
+                                               viz::LocalSurfaceIdAllocation());
+    layer_tree_host()->root_layer()->SetBounds(gfx::Size(10, 10));
+    layer_ = FakePictureLayer::Create(&client_);
+    layer_tree_host()->root_layer()->AddChild(layer_);
+    client_.set_bounds(layer_->bounds());
+
+    // Values chosen arbitrarily
+    SkColor color = SK_ColorDKGRAY;
+    double diameter = 1.000002;
+    gfx::PointF point = gfx::PointF(135, 45);
+    gfx::RectF area = gfx::RectF(173, 438);
+    base::TimeTicks timestamp = base::TimeTicks::Now();
+
+    expected_metadata_ =
+        viz::DelegatedInkMetadata(point, diameter, color, timestamp, area);
+    layer_tree_host()->SetDelegatedInkMetadata(
+        std::make_unique<viz::DelegatedInkMetadata>(
+            expected_metadata_.value()));
+  }
+
+  void DidCommitAndDrawFrame() override {
+    // Cause a redraw to occur.
+    layer_->SetNeedsDisplay();
+  }
+
+  void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
+    if (expected_metadata_.has_value()) {
+      // Now try again with no metadata to confirm everything is cleared out.
+      expected_metadata_.reset();
+    }
+  }
+
+  void ExpectMetadata(bool had_delegated_ink_metadata,
+                      viz::DelegatedInkMetadata* actual_metadata) {
+    if (expected_metadata_.has_value()) {
+      EXPECT_TRUE(had_delegated_ink_metadata);
+      EXPECT_TRUE(actual_metadata);
+      EXPECT_EQ(expected_metadata_->point(), actual_metadata->point());
+      EXPECT_EQ(expected_metadata_->color(), actual_metadata->color());
+      EXPECT_EQ(expected_metadata_->diameter(), actual_metadata->diameter());
+      EXPECT_EQ(expected_metadata_->presentation_area(),
+                actual_metadata->presentation_area());
+      EXPECT_EQ(expected_metadata_->timestamp(), actual_metadata->timestamp());
+    } else {
+      EXPECT_FALSE(had_delegated_ink_metadata);
+      EXPECT_FALSE(actual_metadata);
+      EndTest();
+    }
+  }
+
+  void AfterTest() override {}
+
+  // RenderFrameMetadataObserver implementation.
+  void BindToCurrentThread() override {}
+  void OnRenderFrameSubmission(
+      const RenderFrameMetadata& render_frame_metadata,
+      viz::CompositorFrameMetadata* compositor_frame_metadata,
+      bool force_send) override {
+    ExpectMetadata(render_frame_metadata.has_delegated_ink_metadata,
+                   compositor_frame_metadata->delegated_ink_metadata.get());
+  }
+
+ private:
+  base::Optional<viz::DelegatedInkMetadata> expected_metadata_;
+  FakeContentLayerClient client_;
+  scoped_refptr<Layer> layer_;
+};
+
+SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestDelegatedInkMetadataOnAndOff);
+
 }  // namespace
 }  // namespace cc

cc/trees/render_frame_metadata.h

@@ -55,6 +55,11 @@ class CC_EXPORT RenderFrameMetadata {
   // are the same).
   bool is_mobile_optimized = false;
 
+  // Flag used to notify the browser process to start or stop forwarding points
+  // to viz for use in a delegated ink trail. True the entire time points should
+  // be forwarded, and forwarding stops as soon as it is false again.
+  bool has_delegated_ink_metadata = false;
+
   // The device scale factor used to generate a CompositorFrame.
   float device_scale_factor = 1.f;
 

content/browser/renderer_host/render_widget_host_browsertest.cc

@@ -177,6 +177,7 @@ class RenderWidgetHostTouchEmulatorBrowserTest : public ContentBrowserTest {
   }
 
   RenderWidgetHostImpl* host() { return host_; }
+  RenderWidgetHostViewBase* view() { return view_; }
 
  private:
   RenderWidgetHostViewBase* view_;
@@ -679,4 +680,39 @@ IN_PROC_BROWSER_TEST_F(RenderWidgetHostBrowserTest,
             EvalJs(web_contents(), "`${screen.width}x${screen.height}`"));
 }
 
+class RenderWidgetHostDelegatedInkMetadataTest
+    : public RenderWidgetHostTouchEmulatorBrowserTest {
+ public:
+  RenderWidgetHostDelegatedInkMetadataTest() = default;
+
+  void SetUpCommandLine(base::CommandLine* command_line) override {
+    ContentBrowserTest::SetUpCommandLine(command_line);
+    command_line->AppendSwitchASCII(switches::kEnableBlinkFeatures,
+                                    "DelegatedInkTrails");
+  }
+};
+
+// Confirm that using the |updateInkTrailStartPoint| JS API results in the
+// |request_points_for_delegated_ink_| flag being set on the RWHVB.
+IN_PROC_BROWSER_TEST_F(RenderWidgetHostDelegatedInkMetadataTest,
+                       FlagGetsSetFromRenderFrameMetadata) {
+  ASSERT_TRUE(ExecJs(shell()->web_contents(), R"(
+      let presenter = navigator.ink.requestPresenter('delegated-ink-trail');
+      let style = { color: 'green', diameter: 21 };
+      window.addEventListener('pointermove' , evt => {
+        presenter.then( function(v) {
+          v.updateInkTrailStartPoint(evt, style);
+        });
+      });
+      )"));
+  SimulateRoutedMouseEvent(blink::WebInputEvent::Type::kMouseMove, 10, 10, 0,
+                           false);
+  RunUntilInputProcessed(host());
+  EXPECT_TRUE(view()->is_drawing_delegated_ink_trails_);
+
+  // Confirm that the flag is set back to false when the JS API isn't called.
+  RunUntilInputProcessed(host());
+  EXPECT_FALSE(view()->is_drawing_delegated_ink_trails_);
+}
+
 }  // namespace content

content/browser/renderer_host/render_widget_host_view_base.cc

@@ -125,6 +125,8 @@ void RenderWidgetHostViewBase::OnRenderFrameMetadataChangedAfterActivation() {
       host()->GetRootBrowserAccessibilityManager();
   if (manager)
     manager->SetPageScaleFactor(metadata.page_scale_factor);
+
+  is_drawing_delegated_ink_trails_ = metadata.has_delegated_ink_metadata;
 }
 
 void RenderWidgetHostViewBase::OnRenderFrameSubmission() {}

content/browser/renderer_host/render_widget_host_view_base.h

@@ -620,6 +620,8 @@ class CONTENT_EXPORT RenderWidgetHostViewBase
   FRIEND_TEST_ALL_PREFIXES(
       BrowserSideFlingBrowserTest,
       EarlyTouchpadFlingCancelationOnInertialGSUAckNotConsumed);
+  FRIEND_TEST_ALL_PREFIXES(RenderWidgetHostDelegatedInkMetadataTest,
+                           FlagGetsSetFromRenderFrameMetadata);
 
   void SynchronizeVisualProperties();
 
@@ -660,6 +662,12 @@ class CONTENT_EXPORT RenderWidgetHostViewBase
 
   bool is_evicted_ = false;
 
+  // True when points should be forwarded from the
+  // RenderWidgetHostViewEventHandler directly to viz for use in a delegated
+  // ink trail.
+  // TODO(1052145): Use this to begin forwarding the points to viz.
+  bool is_drawing_delegated_ink_trails_ = false;
+
   base::WeakPtrFactory<RenderWidgetHostViewBase> weak_factory_{this};
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewBase);

content/common/render_frame_metadata.mojom

@@ -36,6 +36,11 @@ struct RenderFrameMetadata {
   // are the same).
   bool is_mobile_optimized;
 
+  // Flag used to notify the browser process to start or stop forwarding points
+  // to viz for use in a delegated ink trail. True the entire time points should
+  // be forwarded, and forwarding stops as soon as it is false again.
+  bool has_delegated_ink_metadata;
+
   // The device scale factor used to generate CompositorFrame.
   float device_scale_factor;
 

content/common/render_frame_metadata_mojom_traits.cc

@@ -21,6 +21,7 @@ bool StructTraits<content::mojom::RenderFrameMetadataDataView,
   out->root_background_color = data.root_background_color();
   out->is_scroll_offset_at_top = data.is_scroll_offset_at_top();
   out->is_mobile_optimized = data.is_mobile_optimized();
+  out->has_delegated_ink_metadata = data.has_delegated_ink_metadata();
   out->device_scale_factor = data.device_scale_factor();
   out->page_scale_factor = data.page_scale_factor();
   out->external_page_scale_factor = data.external_page_scale_factor();

content/common/render_frame_metadata_mojom_traits.h

@@ -40,6 +40,11 @@ struct StructTraits<content::mojom::RenderFrameMetadataDataView,
     return metadata.is_mobile_optimized;
   }
 
+  static bool has_delegated_ink_metadata(
+      const cc::RenderFrameMetadata& metadata) {
+    return metadata.has_delegated_ink_metadata;
+  }
+
   static float device_scale_factor(const cc::RenderFrameMetadata& metadata) {
     return metadata.device_scale_factor;
   }

content/renderer/render_frame_metadata_observer_impl.cc

@@ -146,6 +146,7 @@ bool RenderFrameMetadataObserverImpl::ShouldSendRenderFrameMetadata(
       rfm1.page_scale_factor != rfm2.page_scale_factor ||
       rfm1.external_page_scale_factor != rfm2.external_page_scale_factor ||
       rfm1.is_mobile_optimized != rfm2.is_mobile_optimized ||
+      rfm1.has_delegated_ink_metadata != rfm2.has_delegated_ink_metadata ||
       rfm1.device_scale_factor != rfm2.device_scale_factor ||
       rfm1.viewport_size_in_pixels != rfm2.viewport_size_in_pixels ||
       rfm1.top_controls_height != rfm2.top_controls_height ||