Use HitTestAggregator in GpuRootCompositorFrameSink

components/viz/service/frame_sinks/gpu_root_compositor_frame_sink.cc

 // Copyright 2017 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.
 
 #include "components/viz/service/frame_sinks/gpu_root_compositor_frame_sink.h"
 
 #include <utility>
 
+#include "base/command_line.h"
 #include "components/viz/service/display/display.h"
 #include "components/viz/service/frame_sinks/compositor_frame_sink_support.h"
 #include "components/viz/service/frame_sinks/frame_sink_manager.h"
 
 namespace viz {
 
 GpuRootCompositorFrameSink::GpuRootCompositorFrameSink(
     GpuCompositorFrameSinkDelegate* delegate,
     FrameSinkManager* frame_sink_manager,
     const FrameSinkId& frame_sink_id,
@@ skipping 23 matching lines @@
   DCHECK(display_begin_frame_source_);
   compositor_frame_sink_binding_.set_connection_error_handler(
       base::Bind(&GpuRootCompositorFrameSink::OnClientConnectionLost,
                  base::Unretained(this)));
   compositor_frame_sink_private_binding_.set_connection_error_handler(
       base::Bind(&GpuRootCompositorFrameSink::OnPrivateConnectionLost,
                  base::Unretained(this)));
   frame_sink_manager->RegisterBeginFrameSource(
       display_begin_frame_source_.get(), frame_sink_id);
   display_->Initialize(this, frame_sink_manager->surface_manager());
+
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kUseVizHitTest))
+    hit_test_aggregator_ = base::MakeUnique<HitTestAggregator>();

[Fady Samuel, 2017/07/17 17:08:24]

Do we need a switch at all? Any reason not to always have this created?

[gklassen, 2017/07/17 21:09:52]

It was included to keep runtime cost minimal when this feature is not in use and
to provide a single place to control it's use - but after discussion with you
and with Rob the conclusion seems to be that it's ok to use directly here and an
appropriate switch will be added elsewhere when required. 

Done. 

 }
 
 GpuRootCompositorFrameSink::~GpuRootCompositorFrameSink() {
   support_->frame_sink_manager()->UnregisterBeginFrameSource(
       display_begin_frame_source_.get());
 }
 
 void GpuRootCompositorFrameSink::SetDisplayVisible(bool visible) {
   DCHECK(display_);
   display_->SetVisible(visible);
@@ skipping 49 matching lines @@
   support_->RequestCopyOfSurface(std::move(request));
 }
 
 void GpuRootCompositorFrameSink::DisplayOutputSurfaceLost() {
   // TODO(staraz): Implement this. Client should hear about context/output
   // surface lost.
 }
 
 void GpuRootCompositorFrameSink::DisplayWillDrawAndSwap(
     bool will_draw_and_swap,
-    const cc::RenderPassList& render_pass) {}
+    const cc::RenderPassList& render_pass) {
+  if (hit_test_aggregator_)
+    hit_test_aggregator_->PostTaskAggregate(display_->CurrentSurfaceId());
+}
 
 void GpuRootCompositorFrameSink::DisplayDidDrawAndSwap() {}
 
 void GpuRootCompositorFrameSink::DidReceiveCompositorFrameAck(
     const std::vector<cc::ReturnedResource>& resources) {
   if (client_)
     client_->DidReceiveCompositorFrameAck(resources);
 }
 
 void GpuRootCompositorFrameSink::OnBeginFrame(const cc::BeginFrameArgs& args) {
+  if (hit_test_aggregator_)
+    hit_test_aggregator_->Swap();
   if (client_)
     client_->OnBeginFrame(args);
 }
 
 void GpuRootCompositorFrameSink::ReclaimResources(
     const std::vector<cc::ReturnedResource>& resources) {
   if (client_)
     client_->ReclaimResources(resources);
 }
 
 void GpuRootCompositorFrameSink::WillDrawSurface(
     const LocalSurfaceId& local_surface_id,
     const gfx::Rect& damage_rect) {}
 
 void GpuRootCompositorFrameSink::OnClientConnectionLost() {
   delegate_->OnClientConnectionLost(support_->frame_sink_id());
 }
 
 void GpuRootCompositorFrameSink::OnPrivateConnectionLost() {
   delegate_->OnPrivateConnectionLost(support_->frame_sink_id());
 }
 
 }  // namespace viz