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.cc

@@ -45,14 +45,12 @@
 #include "components/viz/common/surfaces/local_surface_id_allocation.h"
 #include "components/viz/common/viz_utils.h"
 #include "components/viz/host/host_display_client.h"
-#include "components/viz/service/display/display.h"
 #include "components/viz/service/display/display_scheduler.h"
 #include "components/viz/service/display/output_surface.h"
 #include "components/viz/service/display/output_surface_client.h"
 #include "components/viz/service/display/output_surface_frame.h"
 #include "components/viz/service/display_embedder/server_shared_bitmap_manager.h"
 #include "components/viz/service/frame_sinks/direct_layer_tree_frame_sink.h"
-#include "components/viz/service/frame_sinks/frame_sink_manager_impl.h"
 #include "content/browser/browser_main_loop.h"
 #include "content/browser/compositor/surface_utils.h"
 #include "content/browser/gpu/compositor_util.h"
@@ -415,10 +413,9 @@ CompositorImpl::CompositorImpl(CompositorClient* client,
       needs_animate_(false),
       pending_frames_(0U),
       layer_tree_frame_sink_request_pending_(false),
-      enable_surface_synchronization_(
-          features::IsSurfaceSynchronizationEnabled()),
-      enable_viz_(features::IsVizDisplayCompositorEnabled()),
       weak_factory_(this) {
+  CHECK(features::IsVizDisplayCompositorEnabled());
+  CHECK(features::IsSurfaceSynchronizationEnabled());
   DCHECK(client);
 
   SetRootWindow(root_window);
@@ -457,7 +454,6 @@ void CompositorImpl::SetRootWindow(gfx::NativeWindow root_window) {
   // handle visibility, swapping begin frame sources, etc.
   // These checks ensure we have no begin frame source, and that we don't need
   // to register one on the new window.
-  DCHECK(!display_);
   DCHECK(!window_);
 
   scoped_refptr<cc::Layer> root_layer;
@@ -542,7 +538,7 @@ void CompositorImpl::CreateLayerTreeHost() {
 
   cc::LayerTreeSettings settings;
   settings.use_zero_copy = true;
-  settings.enable_surface_synchronization = enable_surface_synchronization_;
+  settings.enable_surface_synchronization = true;
   settings.build_hit_test_data = features::IsVizHitTestingSurfaceLayerEnabled();
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
@@ -614,38 +610,21 @@ void CompositorImpl::TearDownDisplayAndUnregisterRootFrameSink() {
   // https://crbug.com/899705
   SCOPED_UMA_HISTOGRAM_LONG_TIMER("CompositorImplAndroid.TearDownDisplayTime");
 
-  if (enable_viz_) {
-    // Make a best effort to try to complete pending readbacks.
-    // TODO(crbug.com/637035): Consider doing this in a better way,
-    // ideally with the guarantee of readbacks completing.
-    if (display_private_ && HavePendingReadbacks()) {
-      // Note that while this is not a Sync IPC, the call to
-      // InvalidateFrameSinkId below will end up triggering a sync call to
-      // FrameSinkManager::DestroyCompositorFrameSink, as this is the root
-      // frame sink. Because |display_private_| is an associated interface to
-      // FrameSinkManager, this subsequent sync call will ensure ordered
-      // execution of this call.
-      display_private_->ForceImmediateDrawAndSwapIfPossible();
-    }
-
-    GetHostFrameSinkManager()->InvalidateFrameSinkId(frame_sink_id_);
-    display_private_.reset();
-  } else {
-    // Make a best effort to try to complete pending readbacks.
-    // TODO(crbug.com/637035): Consider doing this in a better way,
-    // ideally with the guarantee of readbacks completing.
-    if (display_ && HavePendingReadbacks())
-      display_->ForceImmediateDrawAndSwapIfPossible();
-
-    if (display_) {
-      CompositorDependenciesAndroid::Get()
-          .frame_sink_manager_impl()
-          ->UnregisterBeginFrameSource(root_window_->GetBeginFrameSource());
-    }
-
-    GetHostFrameSinkManager()->InvalidateFrameSinkId(frame_sink_id_);
-    display_.reset();
+  // Make a best effort to try to complete pending readbacks.
+  // TODO(crbug.com/637035): Consider doing this in a better way,
+  // ideally with the guarantee of readbacks completing.
+  if (display_private_ && HavePendingReadbacks()) {
+    // Note that while this is not a Sync IPC, the call to
+    // InvalidateFrameSinkId below will end up triggering a sync call to
+    // FrameSinkManager::DestroyCompositorFrameSink, as this is the root
+    // frame sink. Because |display_private_| is an associated interface to
+    // FrameSinkManager, this subsequent sync call will ensure ordered
+    // execution of this call.
+    display_private_->ForceImmediateDrawAndSwapIfPossible();
   }
+
+  GetHostFrameSinkManager()->InvalidateFrameSinkId(frame_sink_id_);
+  display_private_.reset();
 }
 
 void CompositorImpl::RegisterRootFrameSink() {
@@ -665,8 +644,6 @@ void CompositorImpl::SetWindowBounds(const gfx::Size& size) {
     host_->SetViewportSizeAndScale(size_, root_window_->GetDipScale(),
                                    GenerateLocalSurfaceId());
   }
-  if (display_)
-    display_->Resize(size);
 
   if (display_private_)
     display_private_->Resize(size);
@@ -779,12 +756,10 @@ void CompositorImpl::OnGpuChannelEstablished(
   display_color_space_ = display::Screen::GetScreen()
                              ->GetDisplayNearestWindow(root_window_)
                              .color_space();
-  gpu::SurfaceHandle surface_handle =
-      enable_viz_ ? gpu::kNullSurfaceHandle : surface_handle_;
   auto context_provider =
       base::MakeRefCounted<viz::ContextProviderCommandBuffer>(
           std::move(gpu_channel_host), factory->GetGpuMemoryBufferManager(),
-          stream_id, stream_priority, surface_handle,
+          stream_id, stream_priority, gpu::kNullSurfaceHandle,
           GURL(std::string("chrome://gpu/CompositorImpl::") +
                std::string("CompositorContextProvider")),
           automatic_flushes, support_locking, support_grcontext,
@@ -794,12 +769,7 @@ void CompositorImpl::OnGpuChannelEstablished(
           viz::command_buffer_metrics::ContextType::BROWSER_COMPOSITOR);
   auto result = context_provider->BindToCurrentThread();
 
-  if (surface_handle != gpu::kNullSurfaceHandle) {
-    // Only use OnContextCreationResult for onscreen contexts, where recovering
-    // from a surface initialization failure is possible by re-creating the
-    // native window.
-    OnContextCreationResult(result);
-  } else if (result == gpu::ContextResult::kFatalFailure) {
+  if (result == gpu::ContextResult::kFatalFailure) {
     LOG(FATAL) << "Fatal failure in creating offscreen context";
   }
 
@@ -808,72 +778,7 @@ void CompositorImpl::OnGpuChannelEstablished(
     return;
   }
 
-  if (enable_viz_) {
-    InitializeVizLayerTreeFrameSink(std::move(context_provider));
-  } else {
-    // Unretained is safe this owns viz::Display which owns OutputSurface.
-    auto display_output_surface = std::make_unique<AndroidOutputSurface>(
-        context_provider, base::BindRepeating(&CompositorImpl::DidSwapBuffers,
-                                              base::Unretained(this)));
-    InitializeDisplay(std::move(display_output_surface),
-                      std::move(context_provider));
-  }
-}
-
-void CompositorImpl::InitializeDisplay(
-    std::unique_ptr<viz::OutputSurface> display_output_surface,
-    scoped_refptr<viz::ContextProvider> context_provider) {
-  DCHECK(layer_tree_frame_sink_request_pending_);
-
-  pending_frames_ = 0;
-
-  if (context_provider) {
-    gpu_capabilities_ = context_provider->ContextCapabilities();
-  }
-
-  viz::FrameSinkManagerImpl* manager =
-      CompositorDependenciesAndroid::Get().frame_sink_manager_impl();
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner =
-      base::ThreadTaskRunnerHandle::Get();
-  auto scheduler = std::make_unique<viz::DisplayScheduler>(
-      root_window_->GetBeginFrameSource(), task_runner.get(),
-      display_output_surface->capabilities().max_frames_pending);
-
-  viz::RendererSettings renderer_settings;
-  renderer_settings.allow_antialiasing = false;
-  renderer_settings.highp_threshold_min = 2048;
-  renderer_settings.auto_resize_output_surface = false;
-  renderer_settings.initial_screen_size =
-      display::Screen::GetScreen()
-          ->GetDisplayNearestWindow(root_window_)
-          .GetSizeInPixel();
-  auto* gpu_memory_buffer_manager = BrowserMainLoop::GetInstance()
-                                        ->gpu_channel_establish_factory()
-                                        ->GetGpuMemoryBufferManager();
-
-  // Don't re-register BeginFrameSource on context loss.
-  const bool should_register_begin_frame_source = !display_;
-
-  display_ = std::make_unique<viz::Display>(
-      nullptr, renderer_settings, frame_sink_id_,
-      std::move(display_output_surface), std::move(scheduler), task_runner);
-
-  auto layer_tree_frame_sink = std::make_unique<viz::DirectLayerTreeFrameSink>(
-      frame_sink_id_, GetHostFrameSinkManager(), manager, display_.get(),
-      nullptr /* display_client */, context_provider,
-      nullptr /* worker_context_provider */, task_runner,
-      gpu_memory_buffer_manager);
-
-  display_->SetVisible(true);
-  display_->Resize(size_);
-  display_->SetColorSpace(display_color_space_, display_color_space_);
-  if (should_register_begin_frame_source) {
-    CompositorDependenciesAndroid::Get()
-        .frame_sink_manager_impl()
-        ->RegisterBeginFrameSource(root_window_->GetBeginFrameSource(),
-                                   frame_sink_id_);
-  }
-  host_->SetLayerTreeFrameSink(std::move(layer_tree_frame_sink));
+  InitializeVizLayerTreeFrameSink(std::move(context_provider));
 }
 
 void CompositorImpl::DidSwapBuffers(const gfx::Size& swap_size) {
@@ -996,10 +901,6 @@ bool CompositorImpl::IsDrawingFirstVisibleFrame() const {
 }
 
 void CompositorImpl::SetVSyncPaused(bool paused) {
-  // No action needed in non-Viz mode, as VSync is handled in WindowAndroid.
-  if (!enable_viz_)
-    return;
-
   if (vsync_paused_ == paused)
     return;
 
@@ -1021,7 +922,6 @@ void CompositorImpl::OnUpdateSupportedRefreshRates(
 
 void CompositorImpl::InitializeVizLayerTreeFrameSink(
     scoped_refptr<viz::ContextProviderCommandBuffer> context_provider) {
-  DCHECK(enable_viz_);
   DCHECK(root_window_);
 
   pending_frames_ = 0;
@@ -1095,12 +995,8 @@ void CompositorImpl::InitializeVizLayerTreeFrameSink(
 }
 
 viz::LocalSurfaceIdAllocation CompositorImpl::GenerateLocalSurfaceId() {
-  if (enable_surface_synchronization_) {
-    local_surface_id_allocator_.GenerateId();
-    return local_surface_id_allocator_.GetCurrentLocalSurfaceIdAllocation();
-  }
-
-  return viz::LocalSurfaceIdAllocation();
+  local_surface_id_allocator_.GenerateId();
+  return local_surface_id_allocator_.GetCurrentLocalSurfaceIdAllocation();
 }
 
 void CompositorImpl::OnContextCreationResult(

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_;