aura: Support releasing the OutputSurface()

ui/compositor/compositor_unittest.cc

 // Copyright 2015 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 "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/test/begin_frame_args_test.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/compositor/compositor.h"
+#include "ui/compositor/compositor_observer.h"
 #include "ui/compositor/test/context_factories_for_test.h"
 
 using testing::Mock;
 using testing::_;
 
 namespace ui {
 namespace {
 
 class MockCompositorBeginFrameObserver : public CompositorBeginFrameObserver {
  public:
   MOCK_METHOD1(OnSendBeginFrame, void(const cc::BeginFrameArgs&));
 };
 
+class WaitForCompositingObserver : public CompositorObserver {
+ public:
+  WaitForCompositingObserver(base::Closure quit_closure)
+      : quit_closure_(quit_closure) {}
+
+  void OnCompositingDidCommit(Compositor* compositor) override {
+    quit_closure_.Run();
+  }
+  void OnCompositingStarted(Compositor* compositor,
+                            base::TimeTicks start_time) override {}
+  void OnCompositingEnded(Compositor* compositor) override {}
+  void OnCompositingAborted(Compositor* compositor) override {}
+  void OnCompositingLockStateChanged(Compositor* compositor) override {}
+  void OnCompositingShuttingDown(Compositor* compositor) override {}
+
+ private:
+  base::Closure quit_closure_;
+};
+
 // Test fixture for tests that require a ui::Compositor with a real task
 // runner.
 class CompositorTest : public testing::Test {
  public:
   CompositorTest() {}
   ~CompositorTest() override {}
 
   void SetUp() override {
     task_runner_ = base::ThreadTaskRunnerHandle::Get();
 
     ui::ContextFactory* context_factory =
         ui::InitializeContextFactoryForTests(false);
 
     compositor_.reset(new ui::Compositor(context_factory, task_runner_));
     compositor_->SetAcceleratedWidget(gfx::kNullAcceleratedWidget);
   }
   void TearDown() override {
     compositor_.reset();
     ui::TerminateContextFactoryForTests();
   }
 
+  void WaitForComposite() {
+    compositor()->ScheduleDraw();
+    base::RunLoop run_loop;
+    WaitForCompositingObserver observer(run_loop.QuitClosure());
+    compositor()->AddObserver(&observer);
+    run_loop.Run();
+    compositor()->RemoveObserver(&observer);

[piman, 2015/10/05 22:21:26]

I think you can use DrawWaiterForTest::WaitForCommit(compositor()); instead of
all this (in ui/compositor/test/draw_waiter_for_test.h)

+  }
+
  protected:
   base::SingleThreadTaskRunner* task_runner() { return task_runner_.get(); }
   ui::Compositor* compositor() { return compositor_.get(); }
 
  private:
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   scoped_ptr<ui::Compositor> compositor_;
 
   DISALLOW_COPY_AND_ASSIGN(CompositorTest);
 };
@@ skipping 62 matching lines @@
   // So, it is not used for newly added observer.
   EXPECT_CALL(test_observer2, OnSendBeginFrame(_)).Times(0);
   compositor()->RemoveBeginFrameObserver(&test_observer);
   compositor()->RemoveBeginFrameObserver(&test_observer2);
   compositor()->AddBeginFrameObserver(&test_observer2);
   Mock::VerifyAndClearExpectations(&test_observer2);
 
   compositor()->RemoveBeginFrameObserver(&test_observer2);
 }
 
+TEST_F(CompositorTest, ReleaseWidgetWithOutputSurfaceNeverCreated) {
+  compositor()->SetVisible(false);
+  EXPECT_EQ(gfx::kNullAcceleratedWidget,
+            compositor()->ReleaseAcceleratedWidget());
+  compositor()->SetAcceleratedWidget(gfx::kNullAcceleratedWidget);
+  compositor()->SetVisible(true);
+}
+
+TEST_F(CompositorTest, CreateAndReleaseOutputSurface) {
+  DCHECK(compositor()->IsVisible());
+  WaitForComposite();
+  compositor()->SetVisible(false);
+  EXPECT_EQ(gfx::kNullAcceleratedWidget,
+            compositor()->ReleaseAcceleratedWidget());
+  compositor()->SetAcceleratedWidget(gfx::kNullAcceleratedWidget);
+  compositor()->SetVisible(true);
+  WaitForComposite();
+}
+
 }  // namespace ui