Allow ui::Compositor to disable commits during tab-switch

ui/compositor/compositor.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 "ui/compositor/compositor.h"
 
 #include <algorithm>
 #include <deque>
 
 #include "base/bind.h"
@@ skipping 58 matching lines @@
                        scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : context_factory_(context_factory),
       root_layer_(NULL),
       widget_(widget),
       surface_id_allocator_(context_factory->CreateSurfaceIdAllocator()),
       task_runner_(task_runner),
       vsync_manager_(new CompositorVSyncManager()),
       device_scale_factor_(0.0f),
       last_started_frame_(0),
       last_ended_frame_(0),
-      disable_schedule_composite_(false),
       compositor_lock_(NULL),
       layer_animator_collection_(this),
       weak_ptr_factory_(this) {
   root_web_layer_ = cc::Layer::Create();
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 
   cc::LayerTreeSettings settings;
   // When impl-side painting is enabled, this will ensure PictureLayers always
   // can have LCD text, to match the previous behaviour with ContentLayers,
@@ skipping 197 matching lines @@
                     animation_observer_list_,
                     OnAnimationStep(args.frame_time));
   if (animation_observer_list_.might_have_observers())
     host_->SetNeedsAnimate();
 }
 
 void Compositor::BeginMainFrameNotExpectedSoon() {
 }
 
 void Compositor::Layout() {
-  // We're sending damage that will be addressed during this composite
-  // cycle, so we don't need to schedule another composite to address it.
-  disable_schedule_composite_ = true;
   if (root_layer_)
     root_layer_->SendDamagedRects();
-  disable_schedule_composite_ = false;
 }
 
 void Compositor::RequestNewOutputSurface() {
   context_factory_->CreateOutputSurface(weak_ptr_factory_.GetWeakPtr());
 }
 
 void Compositor::DidInitializeOutputSurface() {
 }
 
 void Compositor::DidFailToInitializeOutputSurface() {
@@ skipping 10 matching lines @@
 }
 
 void Compositor::DidCommitAndDrawFrame() {
 }
 
 void Compositor::DidCompleteSwapBuffers() {
   FOR_EACH_OBSERVER(CompositorObserver, observer_list_,
                     OnCompositingEnded(this));
 }
 
+void Compositor::SetDeferCommits(bool defer_commits) {
+  host_->SetDeferCommits(defer_commits);

[danakj, 2015/03/11 17:22:55]

You'll now have a state where commits are deferred but IsLocked() will return
false. Is that going to be weird?

I was expecting that you used the lock but just let your code remove the
timeout. But maybe this is okay. Can you give me some confidence in this
potential pitfall?

[ccameron, 2015/03/11 21:46:43]

The timeout for the lock is only so that the UI doesn't hang ... that's not a
concern for Mac (ui::Compositor doesn't draw the UI), so I added something a
flag to disable the timeout and just use a CompositorLock.

+}
+
 void Compositor::DidPostSwapBuffers() {
   base::TimeTicks start_time = gfx::FrameTime::Now();
   FOR_EACH_OBSERVER(CompositorObserver, observer_list_,
                     OnCompositingStarted(this, start_time));
 }
 
 void Compositor::DidAbortSwapBuffers() {
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingAborted(this));
@@ skipping 31 matching lines @@
                     observer_list_,
                     OnCompositingLockStateChanged(this));
 }
 
 void Compositor::CancelCompositorLock() {
   if (compositor_lock_)
     compositor_lock_->CancelLock();
 }
 
 }  // namespace ui