cc: Make scheduling be driven by vsync for android webview.

content/browser/android/in_process/synchronous_compositor_output_surface.cc

 // Copyright 2013 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/android/in_process/synchronous_compositor_output_surface.h"
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/context_provider.h"
@@ skipping 55 matching lines @@
 
 SynchronousCompositorOutputSurface::SynchronousCompositorOutputSurface(
     int routing_id,
     scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue)
     : cc::OutputSurface(
           scoped_ptr<cc::SoftwareOutputDevice>(new SoftwareDevice(this))),
       routing_id_(routing_id),
       registered_(false),
       current_sw_canvas_(nullptr),
       memory_policy_(0),
-      output_surface_client_(nullptr),
-      frame_swap_message_queue_(frame_swap_message_queue),
-      begin_frame_source_(nullptr) {
+      frame_swap_message_queue_(frame_swap_message_queue) {
   capabilities_.deferred_gl_initialization = true;
   capabilities_.draw_and_swap_full_viewport_every_frame = true;
   capabilities_.adjust_deadline_for_parent = false;
   capabilities_.delegated_rendering = true;
   capabilities_.max_frames_pending = 1;
   memory_policy_.priority_cutoff_when_visible =
       gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
 }
 
 SynchronousCompositorOutputSurface::~SynchronousCompositorOutputSurface() {
   DCHECK(CalledOnValidThread());
   if (registered_) {
     SynchronousCompositorRegistry::GetInstance()->UnregisterOutputSurface(
         routing_id_, this);
   }
-  DCHECK(!begin_frame_source_);
 }
 
 bool SynchronousCompositorOutputSurface::BindToClient(
     cc::OutputSurfaceClient* surface_client) {
   DCHECK(CalledOnValidThread());
   if (!cc::OutputSurface::BindToClient(surface_client))
     return false;
 
-  output_surface_client_ = surface_client;
-  output_surface_client_->SetMemoryPolicy(memory_policy_);
+  client_->SetMemoryPolicy(memory_policy_);
 
   SynchronousCompositorRegistry::GetInstance()->RegisterOutputSurface(
       routing_id_, this);
   registered_ = true;
 
   return true;
 }
 
 void SynchronousCompositorOutputSurface::Reshape(
     const gfx::Size& size, float scale_factor) {
   // Intentional no-op: surface size is controlled by the embedder.
 }
 
 void SynchronousCompositorOutputSurface::SwapBuffers(
     cc::CompositorFrame* frame) {
   DCHECK(CalledOnValidThread());
 
   frame_holder_.reset(new cc::CompositorFrame);
   frame->AssignTo(frame_holder_.get());
 
   client_->DidSwapBuffers();
 }
 
-void SynchronousCompositorOutputSurface::SetBeginFrameSource(
-    SynchronousCompositorExternalBeginFrameSource* begin_frame_source) {
-  begin_frame_source_ = begin_frame_source;
+void SynchronousCompositorOutputSurface::Invalidate() {
+  DCHECK(CalledOnValidThread());
+  if (!invalidate_callback_.is_null())
+    invalidate_callback_.Run();
 }
 
 namespace {
 void AdjustTransform(gfx::Transform* transform, gfx::Rect viewport) {
   // CC's draw origin starts at the viewport.
   transform->matrix().postTranslate(-viewport.x(), -viewport.y(), 0);
 }
 } // namespace
 
 bool SynchronousCompositorOutputSurface::InitializeHwDraw(
@@ skipping 64 matching lines @@
 }
 
 void SynchronousCompositorOutputSurface::InvokeComposite(
     const gfx::Transform& transform,
     gfx::Rect viewport,
     gfx::Rect clip,
     gfx::Rect viewport_rect_for_tile_priority,
     gfx::Transform transform_for_tile_priority,
     bool hardware_draw) {
   DCHECK(!frame_holder_.get());
-  DCHECK(begin_frame_source_);
 
   gfx::Transform adjusted_transform = transform;
   AdjustTransform(&adjusted_transform, viewport);
   SetExternalDrawConstraints(adjusted_transform,
                              viewport,
                              clip,
                              viewport_rect_for_tile_priority,
                              transform_for_tile_priority,
                              !hardware_draw);
   SetNeedsRedrawRect(gfx::Rect(viewport.size()));
 
-  begin_frame_source_->BeginFrame();
+  client_->RequestDraw();
 
   // After software draws (which might move the viewport arbitrarily), restore
   // the previous hardware viewport to allow CC's tile manager to prioritize
   // properly.
   if (hardware_draw) {
     cached_hw_transform_ = adjusted_transform;
     cached_hw_viewport_ = viewport;
     cached_hw_clip_ = clip;
     cached_hw_viewport_rect_for_tile_priority_ =
         viewport_rect_for_tile_priority;
@@ skipping 15 matching lines @@
 void SynchronousCompositorOutputSurface::ReturnResources(
     const cc::CompositorFrameAck& frame_ack) {
   ReclaimResources(&frame_ack);
 }
 
 void SynchronousCompositorOutputSurface::SetMemoryPolicy(size_t bytes_limit) {
   DCHECK(CalledOnValidThread());
   memory_policy_.bytes_limit_when_visible = bytes_limit;
   memory_policy_.num_resources_limit = kNumResourcesLimit;
 
-  if (output_surface_client_)
-    output_surface_client_->SetMemoryPolicy(memory_policy_);
+  if (client_)
+    client_->SetMemoryPolicy(memory_policy_);
+}
+
+void SynchronousCompositorOutputSurface::SetInvalidateCallback(
+    const base::Closure& callback) {
+  invalidate_callback_ = callback;
 }
 
 void SynchronousCompositorOutputSurface::SetTreeActivationCallback(
     const base::Closure& callback) {
   DCHECK(client_);
   client_->SetTreeActivationCallback(callback);
 }
 
 void SynchronousCompositorOutputSurface::GetMessagesToDeliver(
     ScopedVector<IPC::Message>* messages) {
   DCHECK(CalledOnValidThread());
   scoped_ptr<FrameSwapMessageQueue::SendMessageScope> send_message_scope =
       frame_swap_message_queue_->AcquireSendMessageScope();
   frame_swap_message_queue_->DrainMessages(messages);
 }
 
 // Not using base::NonThreadSafe as we want to enforce a more exacting threading
 // requirement: SynchronousCompositorOutputSurface() must only be used on the UI
 // thread.
 bool SynchronousCompositorOutputSurface::CalledOnValidThread() const {
   return BrowserThread::CurrentlyOn(BrowserThread::UI);
 }
 
 }  // namespace content