Fix CompositorResizeLock to do something.

ui/compositor/compositor_lock.h

Index: ui/compositor/compositor_lock.h
diff --git a/ui/compositor/compositor_lock.h b/ui/compositor/compositor_lock.h
new file mode 100644
index 0000000000000000000000000000000000000000..23734739a58ce732105575e8119711c0067147e8
--- /dev/null
+++ b/ui/compositor/compositor_lock.h
@@ -0,0 +1,67 @@
+// 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/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "ui/compositor/compositor_export.h"
+
+namespace ui {
+
+class Compositor;
+class CompositorLock;
+
+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 RemoveCompositorLock(CompositorLock*) = 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. The timeout length, or no timeout,
+// can be requested at the time the lock is created.
+// Don't instantiate this class directly, use Compositor::GetCompositorLock.
+class COMPOSITOR_EXPORT 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,
+                          base::WeakPtr<CompositorLockDelegate> delegate);
+  ~CompositorLock();
+
+ private:
+  friend class Compositor;
+  friend class FakeCompositorLock;
+
+  // Causes the CompositorLock to end due to a timeout.
+  void TimeoutLock();
+
+  CompositorLockClient* const client_;
+  base::WeakPtr<CompositorLockDelegate> delegate_;
+
+  DISALLOW_COPY_AND_ASSIGN(CompositorLock);
+};
+
+}  // namespace ui
+
+#endif  // UI_COMPOSITOR_COMPOSITOR_LOCK_H_