Allow compositor locks to extend timeout.

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 <stddef.h>
 
 #include <algorithm>
 #include <deque>
@@ skipping 40 matching lines @@
 Compositor::Compositor(const cc::FrameSinkId& frame_sink_id,
                        ui::ContextFactory* context_factory,
                        ui::ContextFactoryPrivate* context_factory_private,
                        scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : context_factory_(context_factory),
       context_factory_private_(context_factory_private),
       frame_sink_id_(frame_sink_id),
       task_runner_(task_runner),
       vsync_manager_(new CompositorVSyncManager()),
       layer_animator_collection_(this),
+      scheduled_timeout_(base::TimeTicks()),
+      allow_locks_to_extend_timeout_(false),
       weak_ptr_factory_(this),
       lock_timeout_weak_ptr_factory_(this) {
   if (context_factory_private) {
     context_factory_private->GetSurfaceManager()->RegisterFrameSinkId(
         frame_sink_id_);
   }
   root_web_layer_ = cc::Layer::Create();
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 
@@ skipping 470 matching lines @@
 std::unique_ptr<CompositorLock> Compositor::GetCompositorLock(
     CompositorLockClient* client,
     base::TimeDelta timeout) {
   // This uses the main WeakPtrFactory to break the connection from the lock to
   // the Compositor when the Compositor is destroyed.
   auto lock =
       base::MakeUnique<CompositorLock>(client, weak_ptr_factory_.GetWeakPtr());
   bool was_empty = active_locks_.empty();
   active_locks_.push_back(lock.get());
 
+  bool should_extend_timeout = false;
+  if ((was_empty || allow_locks_to_extend_timeout_) && !timeout.is_zero()) {
+      const base::TimeTicks time_to_timeout = base::TimeTicks::Now() + timeout;
+      // For the first lock, scheduled_timeout.is_null is true,
+      // |time_to_timeout| will always larger than |scheduled_timeout_|. And it
+      // is ok to invalidate the weakptr of |lock_timeout_weak_ptr_factory_|.
+      if (time_to_timeout > scheduled_timeout_) {
+        scheduled_timeout_ = time_to_timeout;
+        should_extend_timeout = true;
+        lock_timeout_weak_ptr_factory_.InvalidateWeakPtrs();
+      }
+    }
+
   if (was_empty) {
     host_->SetDeferCommits(true);
     for (auto& observer : observer_list_)
       observer.OnCompositingLockStateChanged(this);
+  }
 
-    if (!timeout.is_zero()) {
-      // The timeout task uses an independent WeakPtrFactory that is invalidated
-      // when all locks are ended to prevent the timeout from leaking into
-      // another lock that should have its own timeout.
-      task_runner_->PostDelayedTask(
-          FROM_HERE,
-          base::Bind(&Compositor::TimeoutLocks,
-                     lock_timeout_weak_ptr_factory_.GetWeakPtr()),
-          timeout);
-    }
+  if (should_extend_timeout) {
+    // The timeout task uses an independent WeakPtrFactory that is invalidated
+    // when all locks are ended to prevent the timeout from leaking into
+    // another lock that should have its own timeout.
+    task_runner_->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&Compositor::TimeoutLocks,
+                   lock_timeout_weak_ptr_factory_.GetWeakPtr()),
+        timeout);
   }
   return lock;
 }
 
 void Compositor::RemoveCompositorLock(CompositorLock* lock) {
   base::Erase(active_locks_, lock);
   if (active_locks_.empty()) {
     host_->SetDeferCommits(false);
     for (auto& observer : observer_list_)
       observer.OnCompositingLockStateChanged(this);
     lock_timeout_weak_ptr_factory_.InvalidateWeakPtrs();
+    scheduled_timeout_ = base::TimeTicks();
   }
 }
 
 void Compositor::TimeoutLocks() {
   // Make a copy, we're going to cause |active_locks_| to become
   // empty.
   std::vector<CompositorLock*> locks = active_locks_;
   for (auto* lock : locks)
     lock->TimeoutLock();
   DCHECK(active_locks_.empty());
 }
 
 }  // namespace ui