Make SingleThreadProxy a SchedulerClient

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 "base/android/jni_android.h"
@@ skipping 296 matching lines @@
   needs_composite_ = false;
 
   // Only allow compositing once per vsync.
   current_composite_task_->Cancel();
   DCHECK(DidCompositeThisFrame() && !WillComposite());
 
   // Ignore ScheduleComposite() from layer tree changes during layout and
   // animation updates that will already be reflected in the current frame
   // we are about to draw.
   ignore_schedule_composite_ = true;
-  client_->Layout();
 
   const base::TimeTicks frame_time = gfx::FrameTime::Now();
   if (needs_animate_) {
     needs_animate_ = false;
     root_window_->Animate(frame_time);
   }
   ignore_schedule_composite_ = false;
 
   did_post_swapbuffers_ = false;
   host_->Composite(frame_time);
@@ skipping 82 matching lines @@
     settings.allow_antialiasing = false;
     settings.calculate_top_controls_position = false;
     settings.top_controls_height = 0.f;
     settings.highp_threshold_min = 2048;
 
     CommandLine* command_line = 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);
+    // TODO(enne): Update this this compositor to use the scheduler.
+    settings.single_thread_proxy_scheduler = false;
 
     host_ = cc::LayerTreeHost::CreateSingleThreaded(
         this, this, HostSharedBitmapManager::current(), settings);
     host_->SetRootLayer(root_layer_);
 
     host_->SetVisible(true);
     host_->SetLayerTreeHostClientReady();
     host_->SetViewportSize(size_);
     host_->set_has_transparent_background(has_transparent_background_);
     host_->SetDeviceScaleFactor(device_scale_factor_);
@@ skipping 58 matching lines @@
       new WebGraphicsContext3DCommandBufferImpl(surface_id,
                                                 url,
                                                 gpu_channel_host.get(),
                                                 attributes,
                                                 lose_context_when_out_of_memory,
                                                 limits,
                                                 NULL));
 }
 
 void CompositorImpl::Layout() {
-  // TODO: If we get this callback from the SingleThreadProxy, we need
-  // to stop calling it ourselves in CompositorImpl::Composite().
-  NOTREACHED();
+  ignore_schedule_composite_ = true;
   client_->Layout();
+  ignore_schedule_composite_ = false;
 }
 
 scoped_ptr<cc::OutputSurface> CompositorImpl::CreateOutputSurface(
     bool fallback) {
   blink::WebGraphicsContext3D::Attributes attrs;
   attrs.shareResources = true;
   attrs.noAutomaticFlushes = true;
   pending_swapbuffers_ = 0;
 
   DCHECK(window_);
@@ skipping 58 matching lines @@
   if (pending_swapbuffers_-- == kMaxSwapBuffers && needs_composite_)
     PostComposite(COMPOSITE_IMMEDIATELY);
   client_->OnSwapBuffersCompleted(pending_swapbuffers_);
 }
 
 void CompositorImpl::DidAbortSwapBuffers() {
   TRACE_EVENT0("compositor", "CompositorImpl::DidAbortSwapBuffers");
   // This really gets called only once from
   // SingleThreadProxy::DidLoseOutputSurfaceOnImplThread() when the
   // context was lost.
+  ScheduleComposite();

[danakj, 2014/06/19 17:20:36]

How come this is needed now?

[enne (OOO), 2014/06/19 20:32:28]

This is the equivalent of the removed lines in void
SingleThreadProxy::CreateAndInitializeOutputSurface():

    // Force another recreation attempt to happen by requesting another commit.
    SetNeedsCommit();

I felt like it made SingleThreadProxy cleaner.  Only this manually scheduled one
needs the scheduled composite.

   client_->OnSwapBuffersCompleted(0);
 }
 
 void CompositorImpl::DidCommit() {
   root_window_->OnCompositingDidCommit();
 }
 
 void CompositorImpl::AttachLayerForReadback(scoped_refptr<cc::Layer> layer) {
   root_layer_->AddChild(layer);
 }
@@ skipping 27 matching lines @@
 }
 
 void CompositorImpl::SetNeedsAnimate() {
   if (!host_)
     return;
 
   host_->SetNeedsAnimate();
 }
 
 }  // namespace content