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 177 matching lines @@
 CompositorImpl::CompositorImpl(CompositorClient* client,
                                gfx::NativeWindow root_window)
     : root_layer_(cc::Layer::Create()),
       has_transparent_background_(false),
       device_scale_factor_(1),
       window_(NULL),
       surface_id_(0),
       client_(client),
       root_window_(root_window),
       did_post_swapbuffers_(false),
-      ignore_schedule_composite_(false),
       needs_composite_(false),
       needs_animate_(false),
       will_composite_immediately_(false),
       composite_on_vsync_trigger_(DO_NOT_COMPOSITE),
       pending_swapbuffers_(0U),
       weak_factory_(this) {
   DCHECK(client);
   DCHECK(root_window);
   ImageTransportFactoryAndroid::AddObserver(this);
   root_window->AttachCompositor(this);
@@ skipping 94 matching lines @@
   }
 
   // Reset state before Layout+Composite since that might create more
   // requests to Composite that we need to respect.
   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;
+  host_->SetDeferCommits(true);

[no sievers, 2014/06/13 21:25:43]

I'm slightly worried that during client_->Layout() below, where the tab stack
syncs its internal representation of the UI with the cc layer tree, we somehow
end up redundantly touching some layer property which keeps us compositing
continuously.

Is it also possible to ignore 'set needs commit'? Otherwise maybe we can come up
with some sort of DCHECK() in the app that if no properties changed in the
original representation we don't end up with a 'needs commit' from the call to
Layout().

[danakj, 2014/06/13 21:41:54]

FWIW You could run with the --strict-layer-property-change-checking flag that
would cause dchecks when this happens.

   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;
+  host_->SetDeferCommits(false);
 
   did_post_swapbuffers_ = false;
   host_->Composite(frame_time);
   if (did_post_swapbuffers_)
     pending_swapbuffers_++;
 
   // Need to track vsync to avoid compositing more than once per frame.
   root_window_->RequestVSyncUpdate();
 }
 
@@ skipping 117 matching lines @@
   if (host_)
     host_->set_has_transparent_background(flag);
 }
 
 void CompositorImpl::SetNeedsComposite() {
   if (!host_.get())
     return;
   DCHECK(!needs_composite_ || WillComposite());
 
   needs_composite_ = true;
   PostComposite(COMPOSITE_IMMEDIATELY);

[no sievers, 2014/06/13 21:25:43]

Does this need to become host_->SetNeedsCommit()?

Does PostComposite() need to go away entirely? What happens if we directly call
Composite?

[enne (OOO), 2014/06/17 17:15:23]

Hmm, I was trying to minimally change this code, but it looks like maybe I need
to convert the browser compositor to not call composite directly and just be
scheduled by the scheduler as well.

 }
 
 static scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
 CreateGpuProcessViewContext(
     const scoped_refptr<GpuChannelHost>& gpu_channel_host,
     const blink::WebGraphicsContext3D::Attributes attributes,
     int surface_id) {
   DCHECK(gpu_channel_host);
 
   GURL url("chrome://gpu/Compositor::createContext3D");
@@ skipping 54 matching lines @@
 
   return scoped_ptr<cc::OutputSurface>(
       new OutputSurfaceWithoutParent(context_provider));
 }
 
 void CompositorImpl::OnLostResources() {
   client_->DidLoseResources();
   ui_resource_provider_.UIResourcesAreInvalid();
 }
 
-void CompositorImpl::ScheduleComposite() {
-  DCHECK(!needs_composite_ || WillComposite());
-  if (ignore_schedule_composite_)
-    return;
-
-  needs_composite_ = true;
-  // We currently expect layer tree invalidations at most once per frame
-  // during normal operation and therefore try to composite immediately
-  // to minimize latency.
-  PostComposite(COMPOSITE_IMMEDIATELY);
-}
-
-void CompositorImpl::ScheduleAnimation() {
-  DCHECK(!needs_animate_ || needs_composite_);
-  DCHECK(!needs_composite_ || WillComposite());
-  needs_animate_ = true;
-
-  if (needs_composite_)
-    return;
-
-  TRACE_EVENT0("cc", "CompositorImpl::ScheduleAnimation");
-  needs_composite_ = true;
-  PostComposite(COMPOSITE_EVENTUALLY);
-}
-
 void CompositorImpl::DidPostSwapBuffers() {
   TRACE_EVENT0("compositor", "CompositorImpl::DidPostSwapBuffers");
   did_post_swapbuffers_ = true;
 }
 
 void CompositorImpl::DidCompleteSwapBuffers() {
   TRACE_EVENT0("compositor", "CompositorImpl::DidCompleteSwapBuffers");
   DCHECK_GT(pending_swapbuffers_, 0U);
   if (pending_swapbuffers_-- == kMaxSwapBuffers && needs_composite_)
     PostComposite(COMPOSITE_IMMEDIATELY);
@@ skipping 45 matching lines @@
 }
 
 void CompositorImpl::SetNeedsAnimate() {
   if (!host_)
     return;
 
   host_->SetNeedsAnimate();
 }
 
 }  // namespace content