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 DrawResult PrepareToDrawOnThread(
     43       LayerTreeHostImpl* host_impl,
     44       LayerTreeHostImpl::FrameData* frame,
     45       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 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 DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
     93                                            LayerTreeHostImpl::FrameData* frame,
     94                                            DrawResult draw_result) OVERRIDE {
     95     frame->render_passes.clear();
     96     frame->render_passes_by_id.clear();
     97 
     98     TestRenderPass* child_pass = AddRenderPass(&frame->render_passes,
     99                                                RenderPassId(2, 1),
    100                                                gfx::Rect(3, 3, 10, 10),
    101                                                gfx::Transform());
    102     child_pass->AppendOneOfEveryQuadType(host_impl->resource_provider(),
    103                                          RenderPassId(0, 0));
    104 
    105     TestRenderPass* pass = AddRenderPass(&frame->render_passes,
    106                                          RenderPassId(1, 1),
    107                                          gfx::Rect(3, 3, 10, 10),
    108                                          gfx::Transform());
    109     pass->AppendOneOfEveryQuadType(
    110         host_impl->resource_provider(), child_pass->id);
    111     return draw_result;
    112   }
    113 
    114   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
    115     EXPECT_EQ(0u, output_surface_->num_sent_frames());
    116   }
    117 
    118   virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
    119                                    bool result) OVERRIDE {
    120     EXPECT_TRUE(result);
    121     EXPECT_EQ(1u, output_surface_->num_sent_frames());
    122 
    123     const CompositorFrame& last_frame = output_surface_->last_sent_frame();
    124     ASSERT_TRUE(last_frame.delegated_frame_data);
    125 
    126     EXPECT_EQ(2u, last_frame.delegated_frame_data->render_pass_list.size());
    127     // Each render pass has 11 resources in it. And the root render pass has a
    128     // mask resource used when drawing the child render pass, as well as its
    129     // replica (it's added twice). The number 11 may change if
    130     // AppendOneOfEveryQuadType() is updated, and the value here should be
    131     // updated accordingly.
    132     EXPECT_EQ(24u, last_frame.delegated_frame_data->resource_list.size());
    133 
    134     EndTest();
    135   }
    136 };
    137 
    138 SINGLE_AND_MULTI_THREAD_DELEGATING_RENDERER_TEST_F(
    139     DelegatingRendererTestResources);
    140 
    141 }  // namespace cc
    142