Fix CompositorResizeLock to do something.

ui/compositor/compositor_lock.h

+// Copyright 2017 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.
+
+#ifndef UI_COMPOSITOR_COMPOSITOR_LOCK_H_
+#define UI_COMPOSITOR_COMPOSITOR_LOCK_H_
+
+#include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
+#include "base/time/time.h"
+#include "ui/compositor/compositor_export.h"
+
+namespace base {
+class SequencedTaskRunner;
+}
+
+namespace ui {
+
+class Compositor;
+
+class CompositorLockClient {
+ public:
+  virtual ~CompositorLockClient() {}
+
+  // Called if the CompositorLock ends before being destroyed due to timeout.
+  virtual void CompositorLockTimedOut() = 0;
+};
+
+class CompositorLockDelegate {
+ public:
+  virtual ~CompositorLockDelegate() {}
+
+  // Called to perform the unlock operation.
+  virtual void DoUnlockCompositor() = 0;
+};
+
+// This class represents a lock on the compositor, that can be used to prevent
+// commits to the compositor tree while we're waiting for an asynchronous
+// event. The typical use case is when waiting for a renderer to produce a frame
+// at the right size. The caller keeps a reference on this object, and drops the
+// reference once it desires to release the lock.
+// By default, the lock will be cancelled after a short timeout to ensure
+// responsiveness of the UI, so the compositor tree should be kept in a
+// "reasonable" state while the lock is held. If the compositor sets
+// locks to not time out, then the lock will remain in effect until destroyed.
+// Don't instantiate this class directly, use Compositor::GetCompositorLock.
+class COMPOSITOR_EXPORT CompositorLock
+    : public base::RefCounted<CompositorLock> {
+ public:
+  // The |client| is informed about events from the CompositorLock. The
+  // |delegate| is used to perform actual unlocking. If |timeout| is zero then
+  // no timeout is scheduled, else a timeout is scheduled on the |task_runner|.
+  explicit CompositorLock(CompositorLockClient* client,
+                          CompositorLockDelegate* delegate,
+                          base::SequencedTaskRunner* task_runner,
+                          base::TimeDelta timeout);
+
+ private:
+  friend class base::RefCounted<CompositorLock>;
+  friend class FakeCompositorLock;  // For tests.
+
+  ~CompositorLock();
+
+  void TimeoutLock();
+
+  CompositorLockClient* const client_;
+  CompositorLockDelegate* delegate_;
+  base::WeakPtrFactory<CompositorLock> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(CompositorLock);
+};
+
+}  // namespace ui
+
+#endif  // UI_COMPOSITOR_COMPOSITOR_LOCK_H_