Home | History | Annotate | Download | only in output 
      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 bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
     43                                      LayerTreeHostImpl::FrameData* frame,
     44                                      bool result)
     45       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 true;
     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 bool PrepareToDrawOnThread(
     93       LayerTreeHostImpl* host_impl,
     94       LayerTreeHostImpl::FrameData* frame,
     95       bool 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 true;
    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. The number 10 may
    132     // change if AppendOneOfEveryQuadType() is updated, and the value here
    133     // should be updated accordingly.
    134     EXPECT_EQ(
    135         21u, last_frame.delegated_frame_data->resource_list.size());
    136 
    137     EndTest();
    138   }
    139 };
    140 
    141 SINGLE_AND_MULTI_THREAD_DELEGATING_RENDERER_TEST_F(
    142     DelegatingRendererTestResources);
    143 
    144 }  // namespace cc
    145