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 29 matching lines @@
 const double kTestRefreshRate = 200.0;
 
 const int kCompositorLockTimeoutMs = 67;
 
 }  // namespace
 
 namespace ui {
 
 CompositorLock::CompositorLock(Compositor* compositor)
     : compositor_(compositor) {
-  compositor_->task_runner_->PostDelayedTask(
-      FROM_HERE,
-      base::Bind(&CompositorLock::CancelLock, AsWeakPtr()),
-      base::TimeDelta::FromMilliseconds(kCompositorLockTimeoutMs));
+  if (compositor_->locks_will_time_out_) {
+    compositor_->task_runner_->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&CompositorLock::CancelLock, AsWeakPtr()),
+        base::TimeDelta::FromMilliseconds(kCompositorLockTimeoutMs));
+  }
 }
 
 CompositorLock::~CompositorLock() {
   CancelLock();
 }
 
 void CompositorLock::CancelLock() {
   if (!compositor_)
     return;
   compositor_->UnlockCompositor();
   compositor_ = NULL;
 }
 
 Compositor::Compositor(gfx::AcceleratedWidget widget,
                        ui::ContextFactory* context_factory,
                        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),
+      locks_will_time_out_(true),
       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 35 matching lines @@
 
 void Compositor::SetLayerTreeDebugState(
     const cc::LayerTreeDebugState& debug_state) {
   host_->SetDebugState(debug_state);
 }
 
 const cc::RendererSettings& Compositor::GetRendererSettings() const {
   return host_->settings().renderer_settings;
 }
 
 scoped_refptr<CompositorLock> Compositor::GetCompositorLock() {

[danakj, 2015/03/12 00:07:15]

Rather than adding state to ui::Compositor class, how about
GetCompositorLockWithoutTimeout() and just pass false to the CompositorLock?

[ccameron, 2015/03/12 01:01:34]

This was the approach that I first went with, but then I realized that I want
"whether or not locks to time out" to be a property of the ui::Compositor class.
The reason is that things like the DelegatedFrameHost will create locks, and I
will want them to be WithoutTimeout on Mac and WithTimeout on Aura.

I considered adding a LockBehavior property to the constructor of the
ui::Compositor (because there's really no reason for it to be mutable state),
but went against that because I wasn't sure if this smallish property warranted
that esteemed a position. Do you think that having it as a ctor-arg would be
better?

   if (!compositor_lock_) {
     compositor_lock_ = new CompositorLock(this);
     host_->SetDeferCommits(true);
     FOR_EACH_OBSERVER(CompositorObserver,
                       observer_list_,
                       OnCompositingLockStateChanged(this));
   }
   return compositor_lock_;
 }
 
 void Compositor::UnlockCompositor() {
   DCHECK(compositor_lock_);
   compositor_lock_ = NULL;
   host_->SetDeferCommits(false);
   FOR_EACH_OBSERVER(CompositorObserver,
                     observer_list_,
                     OnCompositingLockStateChanged(this));
 }
 
 void Compositor::CancelCompositorLock() {
   if (compositor_lock_)
     compositor_lock_->CancelLock();
 }
 
 }  // namespace ui