Android Viz Clean-up: Remove non-viz from CompositorImpl+DFHA

Now that viz is required, remove non-viz code from CompositorImpl
and DelegatedFrameHostAndroid.

Bug: 978640
Change-Id: Ia18074ea6d43baaaa0129cd48593db9a93db27c8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1677233
Commit-Queue: Eric Karl <ericrk@chromium.org>
Reviewed-by: Khushal <khushalsagar@chromium.org>
Cr-Commit-Position: refs/heads/master@{#678460}

content/browser/renderer_host/compositor_impl_android.h

@@ -53,7 +53,6 @@ class ExternalBeginFrameControllerClientImpl;
 }
 
 namespace viz {
-class Display;
 class FrameSinkId;
 class HostDisplayClient;
 class OutputSurface;
@@ -221,8 +220,6 @@ class CONTENT_EXPORT CompositorImpl
   std::unique_ptr<cc::LayerTreeHost> host_;
   ui::ResourceManagerImpl resource_manager_;
 
-  std::unique_ptr<viz::Display> display_;
-
   gfx::ColorSpace display_color_space_;
   gfx::Size size_;
   bool requires_alpha_channel_ = false;
@@ -254,12 +251,6 @@ class CONTENT_EXPORT CompositorImpl
       pending_child_frame_sink_ids_;
   bool has_submitted_frame_since_became_visible_ = false;
 
-  // If true, we are using surface synchronization.
-  const bool enable_surface_synchronization_;
-
-  // If true, we are using a Viz process.
-  const bool enable_viz_;
-
   // Viz-specific members for communicating with the display.
   viz::mojom::DisplayPrivateAssociatedPtr display_private_;
   std::unique_ptr<viz::HostDisplayClient> display_client_;

content/browser/renderer_host/delegated_frame_host_client_android.cc

@@ -15,26 +15,6 @@ DelegatedFrameHostClientAndroid::DelegatedFrameHostClientAndroid(
 
 DelegatedFrameHostClientAndroid::~DelegatedFrameHostClientAndroid() {}
 
-void DelegatedFrameHostClientAndroid::SetBeginFrameSource(
-    viz::BeginFrameSource* begin_frame_source) {
-  render_widget_host_view_->SetBeginFrameSource(begin_frame_source);
-}
-
-void DelegatedFrameHostClientAndroid::DidReceiveCompositorFrameAck(
-    const std::vector<viz::ReturnedResource>& resources) {
-  render_widget_host_view_->DidReceiveCompositorFrameAck(resources);
-}
-
-void DelegatedFrameHostClientAndroid::DidPresentCompositorFrames(
-    const viz::FrameTimingDetailsMap& timing_details) {
-  render_widget_host_view_->DidPresentCompositorFrames(timing_details);
-}
-
-void DelegatedFrameHostClientAndroid::ReclaimResources(
-    const std::vector<viz::ReturnedResource>& resources) {
-  render_widget_host_view_->ReclaimResources(resources);
-}
-
 void DelegatedFrameHostClientAndroid::OnFrameTokenChanged(
     uint32_t frame_token) {
   render_widget_host_view_->OnFrameTokenChangedForView(frame_token);

content/browser/renderer_host/delegated_frame_host_client_android.h

@@ -23,13 +23,6 @@ class CONTENT_EXPORT DelegatedFrameHostClientAndroid
 
  private:
   // DelegatedFrameHostAndroid::Client implementation.
-  void SetBeginFrameSource(viz::BeginFrameSource* begin_frame_source) override;
-  void DidPresentCompositorFrames(
-      const viz::FrameTimingDetailsMap& timing_details) override;
-  void DidReceiveCompositorFrameAck(
-      const std::vector<viz::ReturnedResource>& resources) override;
-  void ReclaimResources(
-      const std::vector<viz::ReturnedResource>& resources) override;
   void OnFrameTokenChanged(uint32_t frame_token) override;
   void WasEvicted() override;
 

content/browser/renderer_host/render_widget_host_view_android.cc

@@ -244,9 +244,10 @@ RenderWidgetHostViewAndroid::RenderWidgetHostViewAndroid(
   if (using_browser_compositor_) {
     delegated_frame_host_client_ =
         std::make_unique<DelegatedFrameHostClientAndroid>(this);
+    DCHECK(features::IsSurfaceSynchronizationEnabled());
     delegated_frame_host_ = std::make_unique<ui::DelegatedFrameHostAndroid>(
         &view_, GetHostFrameSinkManager(), delegated_frame_host_client_.get(),
-        host()->GetFrameSinkId(), features::IsSurfaceSynchronizationEnabled());
+        host()->GetFrameSinkId());
     if (is_showing_) {
       delegated_frame_host_->WasShown(
           local_surface_id_allocator_.GetCurrentLocalSurfaceIdAllocation()
@@ -1083,25 +1084,7 @@ void RenderWidgetHostViewAndroid::SubmitCompositorFrame(
     const viz::LocalSurfaceId& local_surface_id,
     viz::CompositorFrame frame,
     base::Optional<viz::HitTestRegionList> hit_test_region_list) {
-  if (!delegated_frame_host_) {
-    DCHECK(!using_browser_compositor_);
-    return;
-  }
-
-  DCHECK(!frame.render_pass_list.empty());
-
-  viz::RenderPass* root_pass = frame.render_pass_list.back().get();
-  current_surface_size_ = root_pass->output_rect.size();
-  bool is_transparent = root_pass->has_transparent_background;
-
-  viz::CompositorFrameMetadata metadata = frame.metadata.Clone();
-
-  delegated_frame_host_->SubmitCompositorFrame(
-      local_surface_id, std::move(frame), std::move(hit_test_region_list));
-
-  // As the metadata update may trigger view invalidation, always call it after
-  // any potential compositor scheduling.
-  OnFrameMetadataUpdated(std::move(metadata), is_transparent);
+  NOTREACHED();
 }
 
 void RenderWidgetHostViewAndroid::OnDidNotProduceFrame(
@@ -1112,8 +1095,7 @@ void RenderWidgetHostViewAndroid::OnDidNotProduceFrame(
     DCHECK(!using_browser_compositor_);
     return;
   }
-
-  delegated_frame_host_->DidNotProduceFrame(ack);
+  NOTREACHED();
 }
 
 void RenderWidgetHostViewAndroid::ClearCompositorFrame() {

ui/android/delegated_frame_host_android.cc

@@ -50,87 +50,34 @@ DelegatedFrameHostAndroid::DelegatedFrameHostAndroid(
     ui::ViewAndroid* view,
     viz::HostFrameSinkManager* host_frame_sink_manager,
     Client* client,
-    const viz::FrameSinkId& frame_sink_id,
-    bool enable_surface_synchronization)
+    const viz::FrameSinkId& frame_sink_id)
     : frame_sink_id_(frame_sink_id),
       view_(view),
       host_frame_sink_manager_(host_frame_sink_manager),
       client_(client),
-      begin_frame_source_(this),
-      enable_surface_synchronization_(enable_surface_synchronization),
-      enable_viz_(features::IsVizDisplayCompositorEnabled()),
       frame_evictor_(std::make_unique<viz::FrameEvictor>(this)) {
   DCHECK(view_);
   DCHECK(client_);
+  DCHECK(features::IsVizDisplayCompositorEnabled());
 
-  if (enable_surface_synchronization_) {
-    constexpr bool is_transparent = false;
-    content_layer_ = CreateSurfaceLayer(
-        viz::SurfaceId(), viz::SurfaceId(), gfx::Size(),
-        cc::DeadlinePolicy::UseDefaultDeadline(), is_transparent);
-    view_->GetLayer()->AddChild(content_layer_);
-  }
+  constexpr bool is_transparent = false;
+  content_layer_ = CreateSurfaceLayer(
+      viz::SurfaceId(), viz::SurfaceId(), gfx::Size(),
+      cc::DeadlinePolicy::UseDefaultDeadline(), is_transparent);
+  view_->GetLayer()->AddChild(content_layer_);
 
   host_frame_sink_manager_->RegisterFrameSinkId(
       frame_sink_id_, this, viz::ReportFirstSurfaceActivation::kNo);
   host_frame_sink_manager_->SetFrameSinkDebugLabel(frame_sink_id_,
                                                    "DelegatedFrameHostAndroid");
-  CreateCompositorFrameSinkSupport();
 }
 
 DelegatedFrameHostAndroid::~DelegatedFrameHostAndroid() {
   EvictDelegatedFrame();
   DetachFromCompositor();
-  support_.reset();
   host_frame_sink_manager_->InvalidateFrameSinkId(frame_sink_id_);
 }
 
-void DelegatedFrameHostAndroid::SubmitCompositorFrame(
-    const viz::LocalSurfaceId& local_surface_id,
-    viz::CompositorFrame frame,
-    base::Optional<viz::HitTestRegionList> hit_test_region_list) {
-  DCHECK(!enable_viz_);
-
-  bool id_changed = (local_surface_id_ != local_surface_id);
-  viz::RenderPass* root_pass = frame.render_pass_list.back().get();
-  const bool has_transparent_background = root_pass->has_transparent_background;
-  const gfx::Size surface_size_in_pixels = frame.size_in_pixels();
-  // Reset |content_layer_| only if surface-sync is not used. When surface-sync
-  // is turned on, |content_layer_| is updated with the appropriate states (see
-  // in EmbedSurface()) instead of being recreated.
-  if (!enable_surface_synchronization_ && content_layer_ && id_changed) {
-    EvictDelegatedFrame();
-  }
-  support_->SubmitCompositorFrame(local_surface_id, std::move(frame),
-                                  std::move(hit_test_region_list));
-  if (enable_surface_synchronization_) {
-    DCHECK(content_layer_);
-    return;
-  }
-
-  if (!content_layer_) {
-    local_surface_id_ = local_surface_id;
-    surface_size_in_pixels_ = surface_size_in_pixels;
-    has_transparent_background_ = has_transparent_background;
-    content_layer_ = CreateSurfaceLayer(
-        viz::SurfaceId(frame_sink_id_, local_surface_id_),
-        viz::SurfaceId(frame_sink_id_, local_surface_id_),
-        surface_size_in_pixels_, cc::DeadlinePolicy::UseDefaultDeadline(),
-        !has_transparent_background_);
-    view_->GetLayer()->AddChild(content_layer_);
-  }
-  content_layer_->SetContentsOpaque(!has_transparent_background_);
-
-  if (id_changed)
-    frame_evictor_->OnNewSurfaceEmbedded();
-}
-
-void DelegatedFrameHostAndroid::DidNotProduceFrame(
-    const viz::BeginFrameAck& ack) {
-  DCHECK(!enable_viz_);
-  support_->DidNotProduceFrame(ack);
-}
-
 const viz::FrameSinkId& DelegatedFrameHostAndroid::GetFrameSinkId() const {
   return frame_sink_id_;
 }
@@ -183,10 +130,6 @@ void DelegatedFrameHostAndroid::EvictDelegatedFrame() {
   if (content_layer_) {
     content_layer_->SetSurfaceId(viz::SurfaceId(),
                                  cc::DeadlinePolicy::UseDefaultDeadline());
-    if (!enable_surface_synchronization_) {
-      content_layer_->RemoveFromParent();
-      content_layer_ = nullptr;
-    }
   }
   if (!HasSavedFrame() || frame_evictor_->visible())
     return;
@@ -225,7 +168,6 @@ bool DelegatedFrameHostAndroid::HasDelegatedContent() const {
 
 void DelegatedFrameHostAndroid::CompositorFrameSinkChanged() {
   EvictDelegatedFrame();
-  CreateCompositorFrameSinkSupport();
   if (registered_parent_compositor_)
     AttachToCompositor(registered_parent_compositor_);
 }
@@ -235,18 +177,12 @@ void DelegatedFrameHostAndroid::AttachToCompositor(
   if (registered_parent_compositor_)
     DetachFromCompositor();
   compositor->AddChildFrameSink(frame_sink_id_);
-  if (!enable_viz_)
-    client_->SetBeginFrameSource(&begin_frame_source_);
   registered_parent_compositor_ = compositor;
 }
 
 void DelegatedFrameHostAndroid::DetachFromCompositor() {
   if (!registered_parent_compositor_)
     return;
-  if (!enable_viz_) {
-    client_->SetBeginFrameSource(nullptr);
-    support_->SetNeedsBeginFrame(false);
-  }
   registered_parent_compositor_->RemoveChildFrameSink(frame_sink_id_);
   registered_parent_compositor_ = nullptr;
 }
@@ -268,9 +204,6 @@ void DelegatedFrameHostAndroid::WasShown(
     const gfx::Size& new_size_in_pixels) {
   frame_evictor_->SetVisible(true);
 
-  if (!enable_surface_synchronization_)
-    return;
-
   EmbedSurface(
       new_local_surface_id, new_size_in_pixels,
       cc::DeadlinePolicy::UseSpecifiedDeadline(FirstFrameTimeoutFrames()));
@@ -280,9 +213,6 @@ void DelegatedFrameHostAndroid::EmbedSurface(
     const viz::LocalSurfaceId& new_local_surface_id,
     const gfx::Size& new_size_in_pixels,
     cc::DeadlinePolicy deadline_policy) {
-  if (!enable_surface_synchronization_)
-    return;
-
   // We should never attempt to embed an invalid surface. Catch this here to
   // track down the root cause. Otherwise we will have vague crashes later on
   // at serialization time.
@@ -333,36 +263,6 @@ void DelegatedFrameHostAndroid::EmbedSurface(
   }
 }
 
-void DelegatedFrameHostAndroid::DidReceiveCompositorFrameAck(
-    const std::vector<viz::ReturnedResource>& resources) {
-  client_->DidReceiveCompositorFrameAck(resources);
-}
-
-void DelegatedFrameHostAndroid::OnBeginFrame(
-    const viz::BeginFrameArgs& args,
-    const viz::FrameTimingDetailsMap& timing_details) {
-  client_->DidPresentCompositorFrames(timing_details);
-  if (enable_viz_) {
-    NOTREACHED();
-    return;
-  }
-  begin_frame_source_.OnBeginFrame(args);
-}
-
-void DelegatedFrameHostAndroid::ReclaimResources(
-    const std::vector<viz::ReturnedResource>& resources) {
-  client_->ReclaimResources(resources);
-}
-
-void DelegatedFrameHostAndroid::OnBeginFramePausedChanged(bool paused) {
-  begin_frame_source_.OnSetBeginFrameSourcePaused(paused);
-}
-
-void DelegatedFrameHostAndroid::OnNeedsBeginFrames(bool needs_begin_frames) {
-  DCHECK(!enable_viz_);
-  support_->SetNeedsBeginFrame(needs_begin_frames);
-}
-
 void DelegatedFrameHostAndroid::OnFirstSurfaceActivation(
     const viz::SurfaceInfo& surface_info) {
   NOTREACHED();
@@ -372,17 +272,6 @@ void DelegatedFrameHostAndroid::OnFrameTokenChanged(uint32_t frame_token) {
   client_->OnFrameTokenChanged(frame_token);
 }
 
-void DelegatedFrameHostAndroid::CreateCompositorFrameSinkSupport() {
-  if (enable_viz_)
-    return;
-
-  constexpr bool is_root = false;
-  constexpr bool needs_sync_points = true;
-  support_.reset();
-  support_ = host_frame_sink_manager_->CreateCompositorFrameSinkSupport(
-      this, frame_sink_id_, is_root, needs_sync_points);
-}
-
 viz::SurfaceId DelegatedFrameHostAndroid::SurfaceId() const {
   return viz::SurfaceId(frame_sink_id_, local_surface_id_);
 }
@@ -401,45 +290,21 @@ void DelegatedFrameHostAndroid::TakeFallbackContentFrom(
   if (HasFallbackSurface() || !other->HasPrimarySurface())
     return;
 
-  if (enable_surface_synchronization_) {
-    const viz::SurfaceId& other_primary = other->content_layer_->surface_id();
-    const base::Optional<viz::SurfaceId>& other_fallback =
-        other->content_layer_->oldest_acceptable_fallback();
-    viz::SurfaceId desired_fallback;
-    if (!other->HasFallbackSurface() ||
-        !other_primary.IsSameOrNewerThan(*other_fallback)) {
-      desired_fallback = other_primary.ToSmallestId();
-    } else {
-      desired_fallback = *other_fallback;
-    }
-    content_layer_->SetOldestAcceptableFallback(
-        other->content_layer_->surface_id().ToSmallestId());
-    return;
-  }
-
-  if (content_layer_) {
-    content_layer_->SetSurfaceId(
-        *other->content_layer_->oldest_acceptable_fallback(),
-        cc::DeadlinePolicy::UseDefaultDeadline());
+  const viz::SurfaceId& other_primary = other->content_layer_->surface_id();
+  const base::Optional<viz::SurfaceId>& other_fallback =
+      other->content_layer_->oldest_acceptable_fallback();
+  viz::SurfaceId desired_fallback;
+  if (!other->HasFallbackSurface() ||
+      !other_primary.IsSameOrNewerThan(*other_fallback)) {
+    desired_fallback = other_primary.ToSmallestId();
   } else {
-    const auto& surface_id = other->SurfaceId();
-    local_surface_id_ = surface_id.local_surface_id();
-    surface_size_in_pixels_ = other->surface_size_in_pixels_;
-    has_transparent_background_ = other->has_transparent_background_;
-    content_layer_ = CreateSurfaceLayer(
-        surface_id, surface_id, other->content_layer_->bounds(),
-        cc::DeadlinePolicy::UseDefaultDeadline(),
-        other->content_layer_->contents_opaque());
-    view_->GetLayer()->AddChild(content_layer_);
+    desired_fallback = *other_fallback;
   }
   content_layer_->SetOldestAcceptableFallback(
-      *other->content_layer_->oldest_acceptable_fallback());
+      other->content_layer_->surface_id().ToSmallestId());
 }
 
 void DelegatedFrameHostAndroid::DidNavigate() {
-  if (!enable_surface_synchronization_)
-    return;
-
   first_local_surface_id_after_navigation_ = local_surface_id_;
 }
 

ui/android/delegated_frame_host_android.h

@@ -9,13 +9,12 @@
 #include "base/memory/ref_counted.h"
 #include "cc/layers/deadline_policy.h"
 #include "components/viz/client/frame_evictor.h"
+#include "components/viz/common/frame_sinks/begin_frame_args.h"
 #include "components/viz/common/frame_sinks/copy_output_request.h"
 #include "components/viz/common/frame_timing_details_map.h"
 #include "components/viz/common/resources/returned_resource.h"
 #include "components/viz/common/surfaces/surface_info.h"
 #include "components/viz/host/host_frame_sink_client.h"
-#include "components/viz/service/frame_sinks/compositor_frame_sink_support.h"
-#include "services/viz/public/interfaces/compositing/compositor_frame_sink.mojom.h"
 #include "ui/android/ui_android_export.h"
 
 namespace cc {
@@ -24,7 +23,6 @@ enum class SurfaceDrawStatus;
 }  // namespace cc
 
 namespace viz {
-class CompositorFrame;
 class HostFrameSinkManager;
 }  // namespace viz
 
@@ -33,22 +31,12 @@ class ViewAndroid;
 class WindowAndroidCompositor;
 
 class UI_ANDROID_EXPORT DelegatedFrameHostAndroid
-    : public viz::mojom::CompositorFrameSinkClient,
-      public viz::ExternalBeginFrameSourceClient,
-      public viz::HostFrameSinkClient,
+    : public viz::HostFrameSinkClient,
       public viz::FrameEvictorClient {
  public:
   class Client {
    public:
     virtual ~Client() {}
-    virtual void SetBeginFrameSource(
-        viz::BeginFrameSource* begin_frame_source) = 0;
-    virtual void DidPresentCompositorFrames(
-        const viz::FrameTimingDetailsMap& timing_details) = 0;
-    virtual void DidReceiveCompositorFrameAck(
-        const std::vector<viz::ReturnedResource>& resources) = 0;
-    virtual void ReclaimResources(
-        const std::vector<viz::ReturnedResource>& resources) = 0;
     virtual void OnFrameTokenChanged(uint32_t frame_token) = 0;
     virtual void WasEvicted() = 0;
   };
@@ -56,8 +44,7 @@ class UI_ANDROID_EXPORT DelegatedFrameHostAndroid
   DelegatedFrameHostAndroid(ViewAndroid* view,
                             viz::HostFrameSinkManager* host_frame_sink_manager,
                             Client* client,
-                            const viz::FrameSinkId& frame_sink_id,
-                            bool enable_surface_synchronization);
+                            const viz::FrameSinkId& frame_sink_id);
 
   ~DelegatedFrameHostAndroid() override;
 
@@ -81,12 +68,6 @@ class UI_ANDROID_EXPORT DelegatedFrameHostAndroid
     return ResizeTimeout() / viz::BeginFrameArgs::DefaultInterval();
   }
 
-  void SubmitCompositorFrame(
-      const viz::LocalSurfaceId& local_surface_id,
-      viz::CompositorFrame frame,
-      base::Optional<viz::HitTestRegionList> hit_test_region_list);
-  void DidNotProduceFrame(const viz::BeginFrameAck& ack);
-
   // FrameEvictorClient implementation.
   void EvictDelegatedFrame() override;
 
@@ -138,24 +119,10 @@ class UI_ANDROID_EXPORT DelegatedFrameHostAndroid
   void DidNavigate();
 
  private:
-  // viz::mojom::CompositorFrameSinkClient implementation.
-  void DidReceiveCompositorFrameAck(
-      const std::vector<viz::ReturnedResource>& resources) override;
-  void OnBeginFrame(const viz::BeginFrameArgs& args,
-                    const viz::FrameTimingDetailsMap& timing_details) override;
-  void ReclaimResources(
-      const std::vector<viz::ReturnedResource>& resources) override;
-  void OnBeginFramePausedChanged(bool paused) override;
-
-  // viz::ExternalBeginFrameSourceClient implementation.
-  void OnNeedsBeginFrames(bool needs_begin_frames) override;
-
   // viz::HostFrameSinkClient implementation.
   void OnFirstSurfaceActivation(const viz::SurfaceInfo& surface_info) override;
   void OnFrameTokenChanged(uint32_t frame_token) override;
 
-  void CreateCompositorFrameSinkSupport();
-
   void ProcessCopyOutputRequest(
       std::unique_ptr<viz::CopyOutputRequest> request);
 
@@ -167,16 +134,8 @@ class UI_ANDROID_EXPORT DelegatedFrameHostAndroid
   WindowAndroidCompositor* registered_parent_compositor_ = nullptr;
   Client* client_;
 
-  std::unique_ptr<viz::CompositorFrameSinkSupport> support_;
-  viz::ExternalBeginFrameSource begin_frame_source_;
-
-  bool has_transparent_background_ = false;
-
   scoped_refptr<cc::SurfaceLayer> content_layer_;
 
-  const bool enable_surface_synchronization_;
-  const bool enable_viz_;
-
   // Whether we've received a frame from the renderer since navigating.
   // Only used when surface synchronization is on.
   viz::LocalSurfaceId first_local_surface_id_after_navigation_;