[android] Make RWHVAndroid a BeginFrameObserver.

content/browser/renderer_host/compositor_impl_android.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/compositor_impl_android.h"
 
 #include <android/bitmap.h>
 #include <android/native_window_jni.h>
 #include <stdint.h>
 #include <unordered_set>
@@ skipping 22 matching lines @@
 #include "cc/layers/layer.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/output_surface_frame.h"
 #include "cc/output/texture_mailbox_deleter.h"
 #include "cc/output/vulkan_in_process_context_provider.h"
 #include "cc/raster/single_thread_task_graph_runner.h"
 #include "cc/resources/ui_resource_manager.h"
-#include "cc/scheduler/begin_frame_source.h"
 #include "cc/surfaces/direct_compositor_frame_sink.h"
 #include "cc/surfaces/display.h"
 #include "cc/surfaces/display_scheduler.h"
 #include "cc/trees/layer_tree_host_in_process.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "components/display_compositor/compositor_overlay_candidate_validator_android.h"
 #include "components/display_compositor/gl_helper.h"
 #include "content/browser/gpu/browser_gpu_memory_buffer_manager.h"
 #include "content/browser/gpu/compositor_util.h"
 #include "content/browser/renderer_host/context_provider_factory_impl_android.h"
@@ skipping 77 matching lines @@
     // -1.
     attributes.alpha_size = 0;
     attributes.red_size = 5;
     attributes.green_size = 6;
     attributes.blue_size = 5;
   }
 
   return attributes;
 }
 
-class ExternalBeginFrameSource : public cc::BeginFrameSource,
-                                 public CompositorImpl::VSyncObserver {
- public:
-  explicit ExternalBeginFrameSource(CompositorImpl* compositor)
-      : compositor_(compositor) {
-    compositor_->AddObserver(this);
-  }
-  ~ExternalBeginFrameSource() override { compositor_->RemoveObserver(this); }
-
-  // cc::BeginFrameSource implementation.
-  void AddObserver(cc::BeginFrameObserver* obs) override;
-  void RemoveObserver(cc::BeginFrameObserver* obs) override;
-  void DidFinishFrame(cc::BeginFrameObserver* obs,
-                      size_t remaining_frames) override {}
-  bool IsThrottled() const override { return true; }
-
-  // CompositorImpl::VSyncObserver implementation.
-  void OnVSync(base::TimeTicks frame_time,
-               base::TimeDelta vsync_period) override;
-
- private:
-  CompositorImpl* const compositor_;
-  std::unordered_set<cc::BeginFrameObserver*> observers_;
-  cc::BeginFrameArgs last_begin_frame_args_;
-};
-
-void ExternalBeginFrameSource::AddObserver(cc::BeginFrameObserver* obs) {
-  DCHECK(obs);
-  DCHECK(observers_.find(obs) == observers_.end());
-
-  observers_.insert(obs);
-  obs->OnBeginFrameSourcePausedChanged(false);
-  compositor_->OnNeedsBeginFramesChange(true);
-
-  if (last_begin_frame_args_.IsValid()) {
-    // Send a MISSED begin frame if necessary.
-    cc::BeginFrameArgs last_args = obs->LastUsedBeginFrameArgs();
-    if (!last_args.IsValid() ||
-        (last_begin_frame_args_.frame_time > last_args.frame_time)) {
-      last_begin_frame_args_.type = cc::BeginFrameArgs::MISSED;
-      // TODO(crbug.com/602485): A deadline doesn't make too much sense
-      // for a missed BeginFrame (the intention rather is 'immediately'),
-      // but currently the retro frame logic is very strict in discarding
-      // BeginFrames.
-      last_begin_frame_args_.deadline =
-          base::TimeTicks::Now() + last_begin_frame_args_.interval;
-      obs->OnBeginFrame(last_begin_frame_args_);
-    }
-  }
-}
-
-void ExternalBeginFrameSource::RemoveObserver(cc::BeginFrameObserver* obs) {
-  DCHECK(obs);
-  DCHECK(observers_.find(obs) != observers_.end());
-
-  observers_.erase(obs);
-  if (observers_.empty())
-    compositor_->OnNeedsBeginFramesChange(false);
-}
-
-void ExternalBeginFrameSource::OnVSync(base::TimeTicks frame_time,
-                                       base::TimeDelta vsync_period) {
-  // frame time is in the past, so give the next vsync period as the deadline.
-  base::TimeTicks deadline = frame_time + vsync_period;
-  last_begin_frame_args_ =
-      cc::BeginFrameArgs::Create(BEGINFRAME_FROM_HERE, frame_time, deadline,
-                                 vsync_period, cc::BeginFrameArgs::NORMAL);
-  std::unordered_set<cc::BeginFrameObserver*> observers(observers_);
-  for (auto* obs : observers)
-    obs->OnBeginFrame(last_begin_frame_args_);
-}
-
 class AndroidOutputSurface : public cc::OutputSurface {
  public:
   explicit AndroidOutputSurface(
       scoped_refptr<ui::ContextProviderCommandBuffer> context_provider)
       : cc::OutputSurface(std::move(context_provider)),
         overlay_candidate_validator_(
             new display_compositor::
                 CompositorOverlayCandidateValidatorAndroid()),
         weak_ptr_factory_(this) {
     capabilities_.max_frames_pending = kMaxDisplaySwapBuffers;
@@ skipping 176 matching lines @@
       resource_manager_(root_window),
       device_scale_factor_(1),
       window_(NULL),
       surface_handle_(gpu::kNullSurfaceHandle),
       client_(client),
       root_window_(root_window),
       needs_animate_(false),
       pending_swapbuffers_(0U),
       num_successive_context_creation_failures_(0),
       compositor_frame_sink_request_pending_(false),
-      needs_begin_frames_(false),
       weak_factory_(this) {
   ui::ContextProviderFactory::GetInstance()
       ->GetSurfaceManager()
       ->RegisterFrameSinkId(frame_sink_id_);
   DCHECK(client);
   DCHECK(root_window);
   DCHECK(root_window->GetLayer() == nullptr);
   root_window->SetLayer(cc::Layer::Create());
   readback_layer_tree_ = cc::Layer::Create();
   readback_layer_tree_->SetHideLayerAndSubtree(true);
@@ skipping 299 matching lines @@
 
   if (context_provider) {
     gpu_capabilities_ = context_provider->ContextCapabilities();
   } else {
     // TODO(danakj): Populate gpu_capabilities_ for VulkanContextProvider.
   }
 
   cc::SurfaceManager* manager =
       ui::ContextProviderFactory::GetInstance()->GetSurfaceManager();
   auto* task_runner = base::ThreadTaskRunnerHandle::Get().get();
-  begin_frame_source_.reset(new ExternalBeginFrameSource(this));
   std::unique_ptr<cc::DisplayScheduler> scheduler(new cc::DisplayScheduler(
       task_runner, display_output_surface->capabilities().max_frames_pending));
 
   display_.reset(new cc::Display(
       HostSharedBitmapManager::current(),
       BrowserGpuMemoryBufferManager::current(),
       host_->GetSettings().renderer_settings, frame_sink_id_,
-      begin_frame_source_.get(), std::move(display_output_surface),
+      root_window_->GetBeginFrameSource(), std::move(display_output_surface),
       std::move(scheduler),
       base::MakeUnique<cc::TextureMailboxDeleter>(task_runner)));
 
   auto compositor_frame_sink =
       vulkan_context_provider
           ? base::MakeUnique<cc::DirectCompositorFrameSink>(
                 frame_sink_id_, manager, display_.get(),
                 vulkan_context_provider)
           : base::MakeUnique<cc::DirectCompositorFrameSink>(
                 frame_sink_id_, manager, display_.get(), context_provider,
                 nullptr, BrowserGpuMemoryBufferManager::current(),
                 HostSharedBitmapManager::current());
 
   display_->SetVisible(true);
   display_->Resize(size_);
   host_->SetCompositorFrameSink(std::move(compositor_frame_sink));
 }
 
-void CompositorImpl::AddObserver(VSyncObserver* observer) {
-  observer_list_.AddObserver(observer);
-}
-
-void CompositorImpl::RemoveObserver(VSyncObserver* observer) {
-  observer_list_.RemoveObserver(observer);
-}
-
 cc::UIResourceId CompositorImpl::CreateUIResource(
     cc::UIResourceClient* client) {
   TRACE_EVENT0("compositor", "CompositorImpl::CreateUIResource");
   return host_->GetUIResourceManager()->CreateUIResource(client);
 }
 
 void CompositorImpl::DeleteUIResource(cc::UIResourceId resource_id) {
   TRACE_EVENT0("compositor", "CompositorImpl::DeleteUIResource");
   host_->GetUIResourceManager()->DeleteUIResource(resource_id);
 }
@@ skipping 25 matching lines @@
 
 void CompositorImpl::AttachLayerForReadback(scoped_refptr<cc::Layer> layer) {
   readback_layer_tree_->AddChild(layer);
 }
 
 void CompositorImpl::RequestCopyOfOutputOnRootLayer(
     std::unique_ptr<cc::CopyOutputRequest> request) {
   root_window_->GetLayer()->RequestCopyOfOutput(std::move(request));
 }
 
-void CompositorImpl::OnVSync(base::TimeTicks frame_time,
-                             base::TimeDelta vsync_period) {
-  for (auto& observer : observer_list_)
-    observer.OnVSync(frame_time, vsync_period);
-  if (needs_begin_frames_)
-    root_window_->RequestVSyncUpdate();
-}
-
-void CompositorImpl::OnNeedsBeginFramesChange(bool needs_begin_frames) {
-  if (needs_begin_frames_ == needs_begin_frames)
-    return;
-
-  needs_begin_frames_ = needs_begin_frames;
-  if (needs_begin_frames_)
-    root_window_->RequestVSyncUpdate();
-}
-
 void CompositorImpl::SetNeedsAnimate() {
   needs_animate_ = true;
   if (!host_->IsVisible())
     return;
 
   TRACE_EVENT0("compositor", "Compositor::SetNeedsAnimate");
   host_->SetNeedsAnimate();
 }
 
 cc::FrameSinkId CompositorImpl::GetFrameSinkId() {
   return frame_sink_id_;
 }
 
 bool CompositorImpl::HavePendingReadbacks() {
   return !readback_layer_tree_->children().empty();
 }
 
 }  // namespace content