Hook up ui::Compositor to Display's BeginFrameSource

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 <utility>
@@ skipping 56 matching lines @@
 #include "ui/android/window_android.h"
 #include "ui/gfx/android/device_display_info.h"
 #include "ui/gfx/swap_result.h"
 
 namespace content {
 
 namespace {
 
 const unsigned int kMaxDisplaySwapBuffers = 1U;
 
+class ExternalBeginFrameSource : public cc::BeginFrameSourceBase,
+                                 public CompositorImpl::VSyncObserver {
+ public:
+  ExternalBeginFrameSource(CompositorImpl* compositor)
+      : compositor_(compositor) {
+    compositor_->AddObserver(this);
+  }
+
+  ~ExternalBeginFrameSource() override {
+    compositor_->RemoveObserver(this);
+  }
+
+  // cc::BeginFrameSourceBase implementation:
+  void OnNeedsBeginFramesChanged(bool needs_begin_frames) override {
+    compositor_->OnNeedsBeginFramesChange(needs_begin_frames);
+  }
+
+  // CompositorImpl::VSyncObserver implementation:
+  void OnVSync(base::TimeTicks frame_time,
+               base::TimeDelta vsync_period) override {
+    CallOnBeginFrame(cc::BeginFrameArgs::Create(
+        BEGINFRAME_FROM_HERE, frame_time, base::TimeTicks::Now(), vsync_period,
+        cc::BeginFrameArgs::NORMAL));
+  }
+
+ private:
+  CompositorImpl* compositor_;
+};
+
 // Used to override capabilities_.adjust_deadline_for_parent to false
 class OutputSurfaceWithoutParent : public cc::OutputSurface,
                                    public CompositorImpl::VSyncObserver {
  public:
   OutputSurfaceWithoutParent(
       CompositorImpl* compositor,
       const scoped_refptr<ContextProviderCommandBuffer>& context_provider,
       const base::Callback<void(gpu::Capabilities)>&
-          populate_gpu_capabilities_callback)
+          populate_gpu_capabilities_callback,
+      scoped_ptr<ExternalBeginFrameSource> begin_frame_source)
       : cc::OutputSurface(context_provider),
         compositor_(compositor),
         populate_gpu_capabilities_callback_(populate_gpu_capabilities_callback),
         swap_buffers_completion_callback_(
             base::Bind(&OutputSurfaceWithoutParent::OnSwapBuffersCompleted,
                        base::Unretained(this))),
         overlay_candidate_validator_(
-            new BrowserCompositorOverlayCandidateValidatorAndroid()) {
+            new BrowserCompositorOverlayCandidateValidatorAndroid()),
+        begin_frame_source_(std::move(begin_frame_source)) {
     capabilities_.adjust_deadline_for_parent = false;
     capabilities_.max_frames_pending = kMaxDisplaySwapBuffers;
   }
 
   ~OutputSurfaceWithoutParent() override { compositor_->RemoveObserver(this); }
 
   void SwapBuffers(cc::CompositorFrame* frame) override {
     GetCommandBufferProxy()->SetLatencyInfo(frame->metadata.latency_info);
     if (frame->gl_frame_data->sub_buffer_rect.IsEmpty()) {
       context_provider_->ContextSupport()->CommitOverlayPlanes();
     } else {
       DCHECK(frame->gl_frame_data->sub_buffer_rect ==
              gfx::Rect(frame->gl_frame_data->size));
       context_provider_->ContextSupport()->Swap();
     }
     client_->DidSwapBuffers();
   }
 
   bool BindToClient(cc::OutputSurfaceClient* client) override {
     if (!OutputSurface::BindToClient(client))
       return false;
 
     GetCommandBufferProxy()->SetSwapBuffersCompletionCallback(
         swap_buffers_completion_callback_.callback());
 
     populate_gpu_capabilities_callback_.Run(
         context_provider_->ContextCapabilities().gpu);
     compositor_->AddObserver(this);
 
+    client->SetBeginFrameSource(begin_frame_source_.get());
+
     return true;
   }
 
+  void DetachFromClient() override {
+    client_->SetBeginFrameSource(nullptr);
+    OutputSurface::DetachFromClient();
+  }
+
   cc::OverlayCandidateValidator* GetOverlayCandidateValidator() const override {
     return overlay_candidate_validator_.get();
   }
 
  private:
   gpu::CommandBufferProxyImpl* GetCommandBufferProxy() {
     ContextProviderCommandBuffer* provider_command_buffer =
         static_cast<content::ContextProviderCommandBuffer*>(
             context_provider_.get());
     gpu::CommandBufferProxyImpl* command_buffer_proxy =
         provider_command_buffer->GetCommandBufferProxy();
     DCHECK(command_buffer_proxy);
     return command_buffer_proxy;
   }
 
   void OnSwapBuffersCompleted(const std::vector<ui::LatencyInfo>& latency_info,
                               gfx::SwapResult result) {
     RenderWidgetHostImpl::CompositorFrameDrawn(latency_info);
     OutputSurface::OnSwapBuffersComplete();
   }
 
   void OnVSync(base::TimeTicks timebase, base::TimeDelta interval) override {
-    CommitVSyncParameters(timebase, interval);
+    client_->CommitVSyncParameters(timebase, interval);
   }
 
+ private:
   CompositorImpl* compositor_;
   base::Callback<void(gpu::Capabilities)> populate_gpu_capabilities_callback_;
   base::CancelableCallback<void(const std::vector<ui::LatencyInfo>&,
                                 gfx::SwapResult)>
       swap_buffers_completion_callback_;
   scoped_ptr<cc::OverlayCandidateValidator> overlay_candidate_validator_;
-};
-
-class ExternalBeginFrameSource : public cc::BeginFrameSourceBase,
-                                 public CompositorImpl::VSyncObserver {
- public:
-  ExternalBeginFrameSource(CompositorImpl* compositor)
-      : compositor_(compositor) {
-    compositor_->AddObserver(this);
-  }
-
-  ~ExternalBeginFrameSource() override {
-    compositor_->RemoveObserver(this);
-  }
-
-  // cc::BeginFrameSourceBase implementation:
-  void OnNeedsBeginFramesChanged(bool needs_begin_frames) override {
-    compositor_->OnNeedsBeginFramesChange(needs_begin_frames);
-  }
-
-  // CompositorImpl::VSyncObserver implementation:
-  void OnVSync(base::TimeTicks frame_time,
-               base::TimeDelta vsync_period) override {
-    CallOnBeginFrame(cc::BeginFrameArgs::Create(
-        BEGINFRAME_FROM_HERE, frame_time, base::TimeTicks::Now(), vsync_period,
-        cc::BeginFrameArgs::NORMAL));
-  }
-
- private:
-  CompositorImpl* compositor_;
+  scoped_ptr<ExternalBeginFrameSource> begin_frame_source_;
 };
 
 static bool g_initialized = false;
 
 base::LazyInstance<cc::SurfaceManager> g_surface_manager =
     LAZY_INSTANCE_INITIALIZER;
 
 int g_surface_id_namespace = 0;
 
 class SingleThreadTaskGraphRunner : public cc::SingleThreadTaskGraphRunner {
@@ skipping 130 matching lines @@
 }
 
 void CompositorImpl::CreateLayerTreeHost() {
   DCHECK(!host_);
 
   cc::LayerTreeSettings settings;
   settings.renderer_settings.refresh_rate = 60.0;
   settings.renderer_settings.allow_antialiasing = false;
   settings.renderer_settings.highp_threshold_min = 2048;
   settings.use_zero_copy = true;
-  settings.use_external_begin_frame_source = true;
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   settings.initial_debug_state.SetRecordRenderingStats(
       command_line->HasSwitch(cc::switches::kEnableGpuBenchmarking));
   settings.initial_debug_state.show_fps_counter =
       command_line->HasSwitch(cc::switches::kUIShowFPSCounter);
   settings.single_thread_proxy_scheduler = true;
 
   cc::LayerTreeHost::InitParams params;
   params.client = this;
   params.shared_bitmap_manager = HostSharedBitmapManager::current();
   params.gpu_memory_buffer_manager = BrowserGpuMemoryBufferManager::current();
   params.task_graph_runner = g_task_graph_runner.Pointer();
   params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
   params.settings = &settings;
-  params.external_begin_frame_source.reset(new ExternalBeginFrameSource(this));
   host_ = cc::LayerTreeHost::CreateSingleThreaded(this, &params);
   DCHECK(!host_->visible());
   host_->SetRootLayer(root_layer_);
   host_->set_surface_id_namespace(surface_id_allocator_->id_namespace());
   host_->SetViewportSize(size_);
   host_->set_has_transparent_background(has_transparent_background_);
   host_->SetDeviceScaleFactor(device_scale_factor_);
 
   if (needs_animate_)
     host_->SetNeedsAnimate();
@@ skipping 181 matching lines @@
       ContextProviderCommandBuffer::Create(
           CreateGpuProcessViewContext(gpu_channel_host, attributes,
                                       surface_id_),
           DISPLAY_COMPOSITOR_ONSCREEN_CONTEXT));
   DCHECK(context_provider.get());
 
   scoped_ptr<cc::OutputSurface> real_output_surface(
       new OutputSurfaceWithoutParent(
           this, context_provider,
           base::Bind(&CompositorImpl::PopulateGpuCapabilities,
-                     base::Unretained(this))));
+                     base::Unretained(this)),
+          make_scoped_ptr(new ExternalBeginFrameSource(this))));
 
   cc::SurfaceManager* manager = GetSurfaceManager();
   display_client_.reset(
       new cc::OnscreenDisplayClient(std::move(real_output_surface), manager,
                                     HostSharedBitmapManager::current(),
                                     BrowserGpuMemoryBufferManager::current(),
                                     host_->settings().renderer_settings,
-                                    base::ThreadTaskRunnerHandle::Get()));
+                                    base::ThreadTaskRunnerHandle::Get().get(),
+                                    surface_id_allocator_->id_namespace()));
   scoped_ptr<cc::SurfaceDisplayOutputSurface> surface_output_surface(
       new cc::SurfaceDisplayOutputSurface(
           manager, surface_id_allocator_.get(), context_provider, nullptr));
 
   display_client_->set_surface_output_surface(surface_output_surface.get());
   surface_output_surface->set_display_client(display_client_.get());
   display_client_->display()->Resize(size_);
   host_->SetOutputSurface(std::move(surface_output_surface));
 }
 
@@ skipping 73 matching lines @@
 
 void CompositorImpl::SetNeedsAnimate() {
   needs_animate_ = true;
   if (!host_->visible())
     return;
 
   host_->SetNeedsAnimate();
 }
 
 }  // namespace content