cc/output/delegating_renderer_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/output/delegating_renderer.h"
   6
   7 #include "cc/test/fake_output_surface.h"
   8 #include "cc/test/layer_tree_test.h"
   9 #include "cc/test/render_pass_test_common.h"
  10 #include "cc/test/render_pass_test_utils.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 namespace cc {
  14
  15 class DelegatingRendererTest : public LayerTreeTest {
  16  public:
  17   DelegatingRendererTest() : LayerTreeTest(), output_surface_(NULL) {}
  18   virtual ~DelegatingRendererTest() {}
  19
  20   virtual scoped_ptr<OutputSurface> CreateOutputSurface(bool fallback)
  21       OVERRIDE {
  22     scoped_ptr<FakeOutputSurface> output_surface =
  23         FakeOutputSurface::CreateDelegating3d();
  24     output_surface_ = output_surface.get();
  25     return output_surface.PassAs<OutputSurface>();
  26   }
  27
  28  protected:
  29   TestWebGraphicsContext3D* context3d_;
  30   FakeOutputSurface* output_surface_;
  31 };
  32
  33 class DelegatingRendererTestDraw : public DelegatingRendererTest {
  34  public:
  35   virtual void BeginTest() OVERRIDE {
  36     layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.5f, 4.f);
  37     PostSetNeedsCommitToMainThread();
  38   }
  39
  40   virtual void AfterTest() OVERRIDE {}
  41
  42   virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
  43       LayerTreeHostImpl* host_impl,
  44       LayerTreeHostImpl::FrameData* frame,
  45       DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
  46     EXPECT_EQ(0u, output_surface_->num_sent_frames());
  47
  48     const CompositorFrame& last_frame = output_surface_->last_sent_frame();
  49     EXPECT_FALSE(last_frame.delegated_frame_data);
  50     EXPECT_FALSE(last_frame.gl_frame_data);
  51     EXPECT_EQ(0.f, last_frame.metadata.min_page_scale_factor);
  52     EXPECT_EQ(0.f, last_frame.metadata.max_page_scale_factor);
  53     return DrawSwapReadbackResult::DRAW_SUCCESS;
  54   }
  55
  56   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
  57     EXPECT_EQ(0u, output_surface_->num_sent_frames());
  58   }
  59
  60   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
  61                                    bool result) OVERRIDE {
  62     EXPECT_TRUE(result);
  63     EXPECT_EQ(1u, output_surface_->num_sent_frames());
  64
  65     const CompositorFrame& last_frame = output_surface_->last_sent_frame();
  66     DelegatedFrameData* last_frame_data = last_frame.delegated_frame_data.get();
  67     ASSERT_TRUE(last_frame.delegated_frame_data);
  68     EXPECT_FALSE(last_frame.gl_frame_data);
  69     EXPECT_EQ(host_impl->DeviceViewport().ToString(),
  70               last_frame_data->render_pass_list.back()->output_rect.ToString());
  71     EXPECT_EQ(0.5f, last_frame.metadata.min_page_scale_factor);
  72     EXPECT_EQ(4.f, last_frame.metadata.max_page_scale_factor);
  73
  74     EXPECT_EQ(
  75         0u, last_frame.delegated_frame_data->resource_list.size());
  76     EXPECT_EQ(1u, last_frame.delegated_frame_data->render_pass_list.size());
  77
  78     EndTest();
  79   }
  80 };
  81
  82 SINGLE_AND_MULTI_THREAD_DELEGATING_RENDERER_TEST_F(DelegatingRendererTestDraw);
  83
  84 class DelegatingRendererTestResources : public DelegatingRendererTest {
  85  public:
  86   virtual void BeginTest() OVERRIDE {
  87     PostSetNeedsCommitToMainThread();
  88   }
  89
  90   virtual void AfterTest() OVERRIDE {}
  91
  92   virtual DrawSwapReadbackResult::DrawResult PrepareToDrawOnThread(
  93       LayerTreeHostImpl* host_impl,
  94       LayerTreeHostImpl::FrameData* frame,
  95       DrawSwapReadbackResult::DrawResult draw_result) OVERRIDE {
  96     frame->render_passes.clear();
  97     frame->render_passes_by_id.clear();
  98
  99     TestRenderPass* child_pass = AddRenderPass(
 100         &frame->render_passes,
 101         RenderPass::Id(2, 1),
 102         gfx::Rect(3, 3, 10, 10),
 103         gfx::Transform());
 104     child_pass->AppendOneOfEveryQuadType(
 105         host_impl->resource_provider(), RenderPass::Id(0, 0));
 106
 107     TestRenderPass* pass = AddRenderPass(
 108         &frame->render_passes,
 109         RenderPass::Id(1, 1),
 110         gfx::Rect(3, 3, 10, 10),
 111         gfx::Transform());
 112     pass->AppendOneOfEveryQuadType(
 113         host_impl->resource_provider(), child_pass->id);
 114     return draw_result;
 115   }
 116
 117   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
 118     EXPECT_EQ(0u, output_surface_->num_sent_frames());
 119   }
 120
 121   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
 122                                    bool result) OVERRIDE {
 123     EXPECT_TRUE(result);
 124     EXPECT_EQ(1u, output_surface_->num_sent_frames());
 125
 126     const CompositorFrame& last_frame = output_surface_->last_sent_frame();
 127     ASSERT_TRUE(last_frame.delegated_frame_data);
 128
 129     EXPECT_EQ(2u, last_frame.delegated_frame_data->render_pass_list.size());
 130     // Each render pass has 10 resources in it. And the root render pass has a
 131     // mask resource used when drawing the child render pass, as well as its
 132     // replica (it's added twice). The number 10 may change if
 133     // AppendOneOfEveryQuadType() is updated, and the value here should be
 134     // updated accordingly.
 135     EXPECT_EQ(
 136         22u, last_frame.delegated_frame_data->resource_list.size());
 137
 138     EndTest();
 139   }
 140 };
 141
 142 SINGLE_AND_MULTI_THREAD_DELEGATING_RENDERER_TEST_F(
 143     DelegatingRendererTestResources);
 144
 145 }  // namespace cc