cc: Emulate BeginFrame in OutputSurfaces that don't support it natively

cc/trees/thread_proxy.cc

 // Copyright 2011 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 "cc/trees/thread_proxy.h"
 
+#include <string>
+
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "cc/base/thread.h"
 #include "cc/input/input_handler.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/scheduler/delay_based_time_source.h"
 #include "cc/scheduler/frame_rate_controller.h"
 #include "cc/scheduler/scheduler.h"
-#include "cc/scheduler/vsync_time_source.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 
 namespace {
 
 // Measured in seconds.
 const double kContextRecreationTickRate = 0.03;
 
 // Measured in seconds.
 const double kSmoothnessTakesPriorityExpirationDelay = 0.25;
 
 }  // namespace
 
 namespace cc {
 
+struct ThreadProxy::ReadbackRequest {
+  CompletionEvent completion;
+  bool success;
+  void* pixels;
+  gfx::Rect rect;
+};
+
+struct ThreadProxy::CommitPendingRequest {
+  CompletionEvent completion;
+  bool commit_pending;
+};
+
+struct ThreadProxy::SchedulerStateRequest {
+  CompletionEvent completion;
+  std::string state;
+};
+
 scoped_ptr<Proxy> ThreadProxy::Create(LayerTreeHost* layer_tree_host,
                                       scoped_ptr<Thread> impl_thread) {
   return make_scoped_ptr(
       new ThreadProxy(layer_tree_host, impl_thread.Pass())).PassAs<Proxy>();
 }
 
 ThreadProxy::ThreadProxy(LayerTreeHost* layer_tree_host,
                          scoped_ptr<Thread> impl_thread)
     : Proxy(impl_thread.Pass()),
       animate_requested_(false),
@@ skipping 12 matching lines @@
       commit_completion_event_on_impl_thread_(NULL),
       completion_event_for_commit_held_on_tree_activation_(NULL),
       texture_acquisition_completion_event_on_impl_thread_(NULL),
       next_frame_is_newly_committed_frame_on_impl_thread_(false),
       throttle_frame_production_(
           layer_tree_host->settings().throttle_frame_production),
       begin_frame_scheduling_enabled_(
           layer_tree_host->settings().begin_frame_scheduling_enabled),
       using_synchronous_renderer_compositor_(
           layer_tree_host->settings().using_synchronous_renderer_compositor),
-      vsync_client_(NULL),
       inside_draw_(false),
       defer_commits_(false),
       renew_tree_priority_on_impl_thread_pending_(false) {
   TRACE_EVENT0("cc", "ThreadProxy::ThreadProxy");
   DCHECK(IsMainThread());
   DCHECK(layer_tree_host_);
 }
 
 ThreadProxy::~ThreadProxy() {
   TRACE_EVENT0("cc", "ThreadProxy::~ThreadProxy");
@@ skipping 243 matching lines @@
             offscreen_context_provider() : NULL;
 
   if (offscreen_contexts)
     offscreen_contexts->VerifyContexts();
   scheduler_on_impl_thread_->DidLoseOutputSurface();
 }
 
 void ThreadProxy::OnSwapBuffersCompleteOnImplThread() {
   DCHECK(IsImplThread());
   TRACE_EVENT0("cc", "ThreadProxy::OnSwapBuffersCompleteOnImplThread");
-  scheduler_on_impl_thread_->DidSwapBuffersComplete();
   Proxy::MainThread()->PostTask(
       base::Bind(&ThreadProxy::DidCompleteSwapBuffers, main_thread_weak_ptr_));
 }
 
-void ThreadProxy::OnVSyncParametersChanged(base::TimeTicks timebase,
-                                           base::TimeDelta interval) {
+void ThreadProxy::SetNeedsBeginFrameOnImplThread(bool enable) {
   DCHECK(IsImplThread());
-  TRACE_EVENT2("cc",
-               "ThreadProxy::OnVSyncParametersChanged",
-               "timebase",
-               (timebase - base::TimeTicks()).InMilliseconds(),
-               "interval",
-               interval.InMilliseconds());
-  scheduler_on_impl_thread_->SetTimebaseAndInterval(timebase, interval);
+  TRACE_EVENT1("cc", "ThreadProxy::SetNeedsBeginFrameOnImplThread",
+               "enable", enable);
+  layer_tree_host_impl_->SetNeedsBeginFrame(enable);
 }
 
 void ThreadProxy::BeginFrameOnImplThread(base::TimeTicks frame_time) {
   DCHECK(IsImplThread());
-  TRACE_EVENT0("cc", "ThreadProxy::OnBeginFrameOnImplThread");
-  if (vsync_client_)
-    vsync_client_->DidVSync(frame_time);
-}
-
-void ThreadProxy::RequestVSyncNotification(VSyncClient* client) {
-  DCHECK(IsImplThread());
-  TRACE_EVENT1(
-      "cc", "ThreadProxy::RequestVSyncNotification", "enable", !!client);
-  vsync_client_ = client;
-  layer_tree_host_impl_->SetNeedsBeginFrame(!!client);
+  TRACE_EVENT0("cc", "ThreadProxy::BeginFrameOnImplThread");
+  scheduler_on_impl_thread_->BeginFrame(frame_time);
 }
 
 void ThreadProxy::OnCanDrawStateChanged(bool can_draw) {
   DCHECK(IsImplThread());
   TRACE_EVENT1(
       "cc", "ThreadProxy::OnCanDrawStateChanged", "can_draw", can_draw);
   scheduler_on_impl_thread_->SetCanDraw(can_draw);
   layer_tree_host_impl_->UpdateBackgroundAnimateTicking(
       !scheduler_on_impl_thread_->WillDrawIfNeeded());
 }
@@ skipping 732 matching lines @@
   DCHECK(IsImplThread());
   *has_initialized_output_surface =
       scheduler_on_impl_thread_->HasInitializedOutputSurface();
   completion->Signal();
 }
 
 void ThreadProxy::InitializeImplOnImplThread(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::InitializeImplOnImplThread");
   DCHECK(IsImplThread());
   layer_tree_host_impl_ = layer_tree_host_->CreateLayerTreeHostImpl(this);
-  const base::TimeDelta display_refresh_interval =
-      base::TimeDelta::FromMicroseconds(
-          base::Time::kMicrosecondsPerSecond /
-          layer_tree_host_->settings().refresh_rate);
-  scoped_ptr<FrameRateController> frame_rate_controller;
-  if (throttle_frame_production_) {
-    if (begin_frame_scheduling_enabled_) {
-      frame_rate_controller.reset(
-          new FrameRateController(VSyncTimeSource::Create(
-              this,
-              using_synchronous_renderer_compositor_ ?
-                  VSyncTimeSource::DISABLE_SYNCHRONOUSLY :
-                  VSyncTimeSource::DISABLE_ON_NEXT_TICK)));
-    } else {
-      frame_rate_controller.reset(
-          new FrameRateController(DelayBasedTimeSource::Create(
-              display_refresh_interval, Proxy::ImplThread())));
-    }
-  } else {
-    frame_rate_controller.reset(new FrameRateController(Proxy::ImplThread()));
-  }
   const LayerTreeSettings& settings = layer_tree_host_->settings();
   SchedulerSettings scheduler_settings;
   scheduler_settings.impl_side_painting = settings.impl_side_painting;
   scheduler_settings.timeout_and_draw_when_animation_checkerboards =
       settings.timeout_and_draw_when_animation_checkerboards;
-  scheduler_on_impl_thread_ = Scheduler::Create(this,
-                                                frame_rate_controller.Pass(),
-                                                scheduler_settings);
+  scheduler_settings.using_synchronous_renderer_compositor =
+      settings.using_synchronous_renderer_compositor;
+  scheduler_on_impl_thread_ = Scheduler::Create(this, scheduler_settings);
   scheduler_on_impl_thread_->SetVisible(layer_tree_host_impl_->visible());
 
   impl_thread_weak_ptr_ = weak_factory_on_impl_thread_.GetWeakPtr();
   completion->Signal();
 }
 
 void ThreadProxy::InitializeOutputSurfaceOnImplThread(
     CompletionEvent* completion,
     scoped_ptr<OutputSurface> output_surface,
     scoped_refptr<ContextProvider> offscreen_context_provider,
     bool* success,
     RendererCapabilities* capabilities) {
   TRACE_EVENT0("cc", "ThreadProxy::InitializeOutputSurfaceOnImplThread");
   DCHECK(IsImplThread());
   DCHECK(IsMainThreadBlocked());
   DCHECK(success);
   DCHECK(capabilities);
 
   layer_tree_host_->DeleteContentsTexturesOnImplThread(
       layer_tree_host_impl_->resource_provider());
 
   *success = layer_tree_host_impl_->InitializeRenderer(output_surface.Pass());
 
   if (*success) {
     *capabilities = layer_tree_host_impl_->GetRendererCapabilities();
-
-    OutputSurface* output_surface_ptr = layer_tree_host_impl_->output_surface();
-    DCHECK(output_surface_ptr);
-    int max_frames_pending =
-        output_surface_ptr->capabilities().max_frames_pending;
-    if (max_frames_pending <= 0)
-      max_frames_pending = FrameRateController::DEFAULT_MAX_FRAMES_PENDING;
-
-    scheduler_on_impl_thread_->SetMaxFramesPending(max_frames_pending);
-
     scheduler_on_impl_thread_->DidCreateAndInitializeOutputSurface();
   }
 
   DidTryInitializeRendererOnImplThread(*success, offscreen_context_provider);
 
   completion->Signal();
 }
 
 void ThreadProxy::DidTryInitializeRendererOnImplThread(
     bool success,
@@ skipping 24 matching lines @@
 
 void ThreadProxy::LayerTreeHostClosedOnImplThread(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::LayerTreeHostClosedOnImplThread");
   DCHECK(IsImplThread());
   layer_tree_host_->DeleteContentsTexturesOnImplThread(
       layer_tree_host_impl_->resource_provider());
   layer_tree_host_impl_->SetNeedsBeginFrame(false);
   scheduler_on_impl_thread_.reset();
   layer_tree_host_impl_.reset();
   weak_factory_on_impl_thread_.InvalidateWeakPtrs();
-  vsync_client_ = NULL;
   completion->Signal();
 }
 
 size_t ThreadProxy::MaxPartialTextureUpdates() const {
   return ResourceUpdateController::MaxPartialTextureUpdates();
 }
 
 ThreadProxy::BeginFrameAndCommitState::BeginFrameAndCommitState()
     : memory_allocation_limit_bytes(0) {}
 
@@ skipping 39 matching lines @@
 void ThreadProxy::CommitPendingOnImplThreadForTesting(
     CommitPendingRequest* request) {
   DCHECK(IsImplThread());
   if (layer_tree_host_impl_->output_surface())
     request->commit_pending = scheduler_on_impl_thread_->CommitPending();
   else
     request->commit_pending = false;
   request->completion.Signal();
 }
 
+std::string ThreadProxy::SchedulerStateAsStringForTesting() {
+  if (IsImplThread())
+    return scheduler_on_impl_thread_->StateAsStringForTesting();
+
+  SchedulerStateRequest scheduler_state_request;
+  {
+    DebugScopedSetMainThreadBlocked main_thread_blocked(this);
+    Proxy::ImplThread()->PostTask(
+        base::Bind(&ThreadProxy::SchedulerStateAsStringOnImplThreadForTesting,
+                   impl_thread_weak_ptr_,
+                   &scheduler_state_request));
+    scheduler_state_request.completion.Wait();
+  }
+  return scheduler_state_request.state;
+}
+
+void ThreadProxy::SchedulerStateAsStringOnImplThreadForTesting(
+    SchedulerStateRequest* request) {
+  DCHECK(IsImplThread());
+  request->state = scheduler_on_impl_thread_->StateAsStringForTesting();
+  request->completion.Signal();
+}
+
 skia::RefPtr<SkPicture> ThreadProxy::CapturePicture() {
   DCHECK(IsMainThread());
   CompletionEvent completion;
   skia::RefPtr<SkPicture> picture;
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
     Proxy::ImplThread()->PostTask(
         base::Bind(&ThreadProxy::CapturePictureOnImplThread,
                    impl_thread_weak_ptr_,
                    &completion,
@@ skipping 92 matching lines @@
       !layer_tree_host_impl_->pending_tree()) {
     TRACE_EVENT_INSTANT0("cc", "ReleaseCommitbyActivation",
                          TRACE_EVENT_SCOPE_THREAD);
     DCHECK(layer_tree_host_impl_->settings().impl_side_painting);
     completion_event_for_commit_held_on_tree_activation_->Signal();
     completion_event_for_commit_held_on_tree_activation_ = NULL;
   }
 }
 
 }  // namespace cc