android_webview/browser/browser_view_renderer_unittest.cc

   1 // Copyright 2014 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 "android_webview/browser/browser_view_renderer.h"
   6 #include "android_webview/browser/child_frame.h"
   7 #include "android_webview/browser/test/rendering_test.h"
   8
   9 namespace android_webview {
  10
  11 class SmokeTest : public RenderingTest {
  12   void StartTest() override {
  13     browser_view_renderer_->SetContinuousInvalidate(true);
  14   }
  15
  16   void WillOnDraw() override {
  17     browser_view_renderer_->SetContinuousInvalidate(false);
  18   }
  19
  20   void DidDrawOnRT(SharedRendererState* functor) override {
  21     EndTest();
  22   }
  23 };
  24
  25 RENDERING_TEST_F(SmokeTest);
  26
  27 class ClearViewTest : public RenderingTest {
  28  public:
  29   ClearViewTest() : on_draw_count_(0u) {}
  30
  31   void StartTest() override {
  32     browser_view_renderer_->SetContinuousInvalidate(true);
  33     browser_view_renderer_->ClearView();
  34   }
  35
  36   void WillOnDraw() override {
  37     on_draw_count_++;
  38     if (on_draw_count_ == 2u) {
  39       browser_view_renderer_->SetContinuousInvalidate(false);
  40     }
  41   }
  42
  43   void DidOnDraw(bool success) override {
  44     if (on_draw_count_ == 1u) {
  45       // First OnDraw should be skipped due to ClearView.
  46       EXPECT_FALSE(success);
  47       browser_view_renderer_->DidUpdateContent();  // Unset ClearView.
  48     } else {
  49       // Following OnDraws should succeed.
  50       EXPECT_TRUE(success);
  51     }
  52   }
  53
  54   void DidDrawOnRT(SharedRendererState* functor) override {
  55     EndTest();
  56   }
  57  private:
  58   size_t on_draw_count_;
  59 };
  60
  61 RENDERING_TEST_F(ClearViewTest);
  62
  63 class TestAnimateInAndOutOfScreen : public RenderingTest {
  64  public:
  65   TestAnimateInAndOutOfScreen()
  66       : on_draw_count_(0u), draw_gl_count_on_rt_(0u) {}
  67
  68   void StartTest() override {
  69     new_constraints_ = ParentCompositorDrawConstraints(
  70         false, gfx::Transform(), gfx::Rect(window_->surface_size()));
  71     new_constraints_.transform.Scale(2.0, 2.0);
  72     browser_view_renderer_->SetContinuousInvalidate(true);
  73   }
  74
  75   void WillOnDraw() override {
  76     browser_view_renderer_->SetContinuousInvalidate(false);
  77     // Step 0: A single onDraw on screen. The parent draw constraints
  78     // of the BVR will updated to be the initial constraints.
  79     // Step 1: A single onDrraw off screen. The parent draw constraints of the
  80     // BVR will be updated to the new constraints.
  81     // Step 2: This onDraw is to introduce the DrawGL that animates the
  82     // webview onto the screen on render thread. End the test when the parent
  83     // draw constraints of BVR is updated to initial constraints.
  84     if (on_draw_count_ == 1u || on_draw_count_ == 2u)
  85       browser_view_renderer_->PrepareToDraw(gfx::Vector2d(), gfx::Rect());
  86   }
  87
  88   void DidOnDraw(bool success) override {
  89     EXPECT_TRUE(success);
  90     on_draw_count_++;
  91   }
  92
  93   bool WillDrawOnRT(SharedRendererState* functor,
  94                     AwDrawGLInfo* draw_info) override {
  95     if (draw_gl_count_on_rt_ == 1u) {
  96       draw_gl_count_on_rt_++;
  97       ui_proxy_->PostTask(FROM_HERE, base::Bind(&RenderingTest::PostInvalidate,
  98                                                 base::Unretained(this)));
  99       return false;
 100     }
 101
 102     draw_info->width = window_->surface_size().width();
 103     draw_info->height = window_->surface_size().height();
 104     draw_info->is_layer = false;
 105
 106     gfx::Transform transform;
 107     if (draw_gl_count_on_rt_ == 0u)
 108       transform = new_constraints_.transform;
 109
 110     transform.matrix().asColMajorf(draw_info->transform);
 111     return true;
 112   }
 113
 114   void DidDrawOnRT(SharedRendererState* functor) override {
 115     draw_gl_count_on_rt_++;
 116   }
 117
 118   bool DrawConstraintsEquals(
 119       const ParentCompositorDrawConstraints& constraints1,
 120       const ParentCompositorDrawConstraints& constraints2) {
 121     if (constraints1.is_layer != constraints2.is_layer ||
 122         constraints1.transform != constraints2.transform)
 123       return false;
 124
 125     return !constraints1.is_layer ||
 126            constraints1.surface_rect == constraints2.surface_rect;
 127   }
 128
 129   void ParentDrawConstraintsUpdated(
 130       const ParentCompositorDrawConstraints& constraints) override {
 131     switch (on_draw_count_) {
 132       case 1u:
 133         EXPECT_TRUE(DrawConstraintsEquals(constraints, new_constraints_));
 134         break;
 135       case 3u:
 136         EXPECT_TRUE(DrawConstraintsEquals(constraints, initial_constraints_));
 137         EndTest();
 138         break;
 139       // There will be a following 4th onDraw. But the hardware renderer won't
 140       // post back the draw constraints in DrawGL because the constraints
 141       // don't change.
 142       default:
 143         FAIL();
 144     }
 145   }
 146
 147  private:
 148   size_t on_draw_count_;
 149   size_t draw_gl_count_on_rt_;
 150   ParentCompositorDrawConstraints initial_constraints_;
 151   ParentCompositorDrawConstraints new_constraints_;
 152 };
 153
 154 RENDERING_TEST_F(TestAnimateInAndOutOfScreen);
 155
 156 }  // namespace android_webview