cc/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/delegating_renderer.h"
   6
   7 #include "cc/test/fake_output_surface.h"
   8 #include "cc/test/layer_tree_test_common.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 ThreadedTest {
  16  public:
  17   DelegatingRendererTest() : ThreadedTest(), output_surface_(NULL) {}
  18   virtual ~DelegatingRendererTest() {}
  19
  20   virtual scoped_ptr<OutputSurface> createOutputSurface() OVERRIDE {
  21     scoped_ptr<FakeWebGraphicsContext3D> context3d =
  22         FakeWebGraphicsContext3D::Create(
  23             WebKit::WebGraphicsContext3D::Attributes());
  24     context3d_ = context3d.get();
  25     scoped_ptr<FakeOutputSurface> output_surface =
  26         FakeOutputSurface::CreateDelegating3d(
  27             context3d.PassAs<WebKit::WebGraphicsContext3D>());
  28     output_surface_ = output_surface.get();
  29     return output_surface.PassAs<OutputSurface>();
  30   }
  31
  32  protected:
  33   FakeWebGraphicsContext3D* context3d_;
  34   FakeOutputSurface* output_surface_;
  35 };
  36
  37 class DelegatingRendererTestDraw : public DelegatingRendererTest {
  38  public:
  39   virtual void beginTest() OVERRIDE {
  40     m_layerTreeHost->setPageScaleFactorAndLimits(1.f, 0.5f, 4.f);
  41     postSetNeedsCommitToMainThread();
  42   }
  43
  44   virtual void afterTest() OVERRIDE {}
  45
  46   virtual bool prepareToDrawOnThread(
  47       LayerTreeHostImpl*, LayerTreeHostImpl::FrameData& frame, bool result)
  48       OVERRIDE {
  49     EXPECT_EQ(0u, output_surface_->num_sent_frames());
  50
  51     CompositorFrame& last_frame = output_surface_->last_sent_frame();
  52     EXPECT_FALSE(last_frame.delegated_frame_data);
  53     EXPECT_FALSE(last_frame.gl_frame_data);
  54     EXPECT_EQ(0.f, last_frame.metadata.min_page_scale_factor);
  55     EXPECT_EQ(0.f, last_frame.metadata.max_page_scale_factor);
  56     return true;
  57   }
  58
  59   virtual void drawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
  60     EXPECT_EQ(1u, output_surface_->num_sent_frames());
  61
  62     CompositorFrame& last_frame = output_surface_->last_sent_frame();
  63     ASSERT_TRUE(last_frame.delegated_frame_data);
  64     EXPECT_FALSE(last_frame.gl_frame_data);
  65     EXPECT_EQ(
  66         host_impl->deviceViewportSize().ToString(),
  67         last_frame.delegated_frame_data->size.ToString());
  68     EXPECT_EQ(0.5f, last_frame.metadata.min_page_scale_factor);
  69     EXPECT_EQ(4.f, last_frame.metadata.max_page_scale_factor);
  70
  71     EXPECT_EQ(
  72         0u, last_frame.delegated_frame_data->resource_list.resources.size());
  73     EXPECT_EQ(1u, last_frame.delegated_frame_data->render_pass_list.size());
  74
  75     endTest();
  76   }
  77 };
  78
  79 SINGLE_AND_MULTI_THREAD_TEST_F(DelegatingRendererTestDraw)
  80
  81 class DelegatingRendererTestResources : public DelegatingRendererTest {
  82  public:
  83   virtual void beginTest() OVERRIDE {
  84     postSetNeedsCommitToMainThread();
  85   }
  86
  87   virtual void afterTest() OVERRIDE {}
  88
  89   virtual bool prepareToDrawOnThread(
  90       LayerTreeHostImpl* host_impl,
  91       LayerTreeHostImpl::FrameData& frame,
  92       bool result) OVERRIDE {
  93
  94     frame.renderPasses.clear();
  95     frame.renderPassesById.clear();
  96
  97     TestRenderPass* child_pass = addRenderPass(
  98         frame.renderPasses,
  99         RenderPass::Id(2, 1),
 100         gfx::Rect(3, 3, 10, 10),
 101         gfx::Transform());
 102     child_pass->AppendOneOfEveryQuadType(
 103         host_impl->resourceProvider(), RenderPass::Id(0, 0));
 104
 105     TestRenderPass* pass = addRenderPass(
 106         frame.renderPasses,
 107         RenderPass::Id(1, 1),
 108         gfx::Rect(3, 3, 10, 10),
 109         gfx::Transform());
 110     pass->AppendOneOfEveryQuadType(
 111         host_impl->resourceProvider(), child_pass->id);
 112     return true;
 113   }
 114
 115   virtual void drawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
 116     EXPECT_EQ(1u, output_surface_->num_sent_frames());
 117
 118     CompositorFrame& last_frame = output_surface_->last_sent_frame();
 119     ASSERT_TRUE(last_frame.delegated_frame_data);
 120
 121     EXPECT_EQ(2u, last_frame.delegated_frame_data->render_pass_list.size());
 122     // Each render pass has 7 resources in it. And the root render pass has a
 123     // mask resource used when drawing the child render pass. The number 7 may
 124     // change if AppendOneOfEveryQuadType is updated, and the value here should
 125     // be updated accordingly.
 126     EXPECT_EQ(
 127         15u, last_frame.delegated_frame_data->resource_list.resources.size());
 128
 129     endTest();
 130   }
 131 };
 132
 133 SINGLE_AND_MULTI_THREAD_TEST_F(DelegatingRendererTestResources)
 134
 135 }  // namespace cc