cc: Setup API to release OutputSurface from LTHClient.

cc/trees/layer_tree_host_unittest_context.cc

 // Copyright 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 "cc/trees/layer_tree_host.h"
 
 #include "base/basictypes.h"
 #include "cc/layers/delegated_frame_provider.h"
 #include "cc/layers/delegated_frame_resource_collection.h"
 #include "cc/layers/heads_up_display_layer.h"
@@ skipping 364 matching lines @@
   }
 
   void DidInitializeOutputSurface() override { EXPECT_TRUE(false); }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostClientNotReadyDoesNotCreateOutputSurface);
 
+// This tests the OutputSurface release logic in the following sequence.
+// SetUp LTH and create and init OutputSurface
+// LTH::SetVisible(false);
+// LTH::ReleaseOutputSurface();
+// ...
+// LTH::SetVisible(true);
+// Create and init new OutputSurface
+class LayerTreeHostClientTakeAwayOutputSurface
+    : public LayerTreeHostContextTest {
+ public:
+  LayerTreeHostClientTakeAwayOutputSurface()
+      : LayerTreeHostContextTest(), setos_counter_(0) {}
+
+  void BeginTest() override { PostSetNeedsCommitToMainThread(); }
+
+  void RequestNewOutputSurface() override {
+    if (layer_tree_host()->visible())
+      CreateAndSetOutputSurface();
+  }
+
+  void CreateAndSetOutputSurface() {
+    scoped_ptr<OutputSurface> surface =
+        LayerTreeHostContextTest::CreateOutputSurface();
+    CHECK(surface);
+    setos_counter_++;
+    layer_tree_host()->SetOutputSurface(surface.Pass());
+  }
+
+  void HideAndReleaseOutputSurface() {
+    EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
+    layer_tree_host()->SetVisible(false);
+    scoped_ptr<OutputSurface> surface =
+        layer_tree_host()->ReleaseOutputSurface();
+    CHECK(surface);
+    surface->context_provider()->DetachFromThread();
+    MainThreadTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&LayerTreeHostClientTakeAwayOutputSurface::MakeVisible,
+                   base::Unretained(this)));
+  }
+
+  void DidInitializeOutputSurface() override {
+    EXPECT_TRUE(layer_tree_host()->visible());
+    if (setos_counter_ == 1) {
+      MainThreadTaskRunner()->PostTask(
+          FROM_HERE, base::Bind(&LayerTreeHostClientTakeAwayOutputSurface::
+                                    HideAndReleaseOutputSurface,
+                                base::Unretained(this)));
+    } else {
+      EndTest();
+    }
+  }
+
+  void MakeVisible() {
+    EXPECT_TRUE(layer_tree_host()->proxy()->IsMainThread());
+    layer_tree_host()->SetVisible(true);
+  }
+
+  void AfterTest() override {}
+
+  int setos_counter_;
+};
+
+SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostClientTakeAwayOutputSurface);
+
 class MultipleCompositeDoesNotCreateOutputSurface
     : public LayerTreeHostContextTest {
  public:
   MultipleCompositeDoesNotCreateOutputSurface()
       : LayerTreeHostContextTest(), request_count_(0) {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->single_thread_proxy_scheduler = false;
     settings->use_zero_copy = true;
   }
@@ skipping 1163 matching lines @@
   void AfterTest() override {}
 
   bool deferred_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostContextTestLoseAfterSendingBeginMainFrame);
 
 }  // namespace
 }  // namespace cc