Unit Test for WebView animating in and out of screen

This makes sure we don't break crbug.com/417479.

BUG=

Review URL: https://codereview.chromium.org/1002013003

Cr-Commit-Position: refs/heads/master@{#321496}

android_webview/browser/browser_view_renderer.cc

@@ -272,6 +272,9 @@ bool BrowserViewRenderer::CompositeHw() {
 
 void BrowserViewRenderer::UpdateParentDrawConstraints() {
   EnsureContinuousInvalidation(true);
+  ParentCompositorDrawConstraints parent_draw_constraints =
+      shared_renderer_state_.GetParentDrawConstraintsOnUI();
+  client_->ParentDrawConstraintsUpdated(parent_draw_constraints);
 }
 
 void BrowserViewRenderer::ReturnUnusedResource(

android_webview/browser/browser_view_renderer_client.h

@@ -11,6 +11,7 @@
 #include "ui/gfx/geometry/vector2d_f.h"
 
 namespace android_webview {
+struct ParentCompositorDrawConstraints;
 
 class BrowserViewRendererClient {
  public:
@@ -54,6 +55,12 @@ class BrowserViewRendererClient {
   // Handle overscroll.
   virtual void DidOverscroll(gfx::Vector2d overscroll_delta) = 0;
 
+  // Visible for testing
+  // Called when the parent draw constraints in browser view renderer gets
+  // updated.
+  virtual void ParentDrawConstraintsUpdated(
+      const ParentCompositorDrawConstraints& draw_constraints) = 0;
+
  protected:
   virtual ~BrowserViewRendererClient() {}
 };

android_webview/browser/browser_view_renderer_unittest.cc

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "android_webview/browser/browser_view_renderer.h"
+#include "android_webview/browser/child_frame.h"
 #include "android_webview/browser/test/rendering_test.h"
 
 namespace android_webview {
@@ -59,4 +60,97 @@ class ClearViewTest : public RenderingTest {
 
 RENDERING_TEST_F(ClearViewTest);
 
+class TestAnimateInAndOutOfScreen : public RenderingTest {
+ public:
+  TestAnimateInAndOutOfScreen()
+      : on_draw_count_(0u), draw_gl_count_on_rt_(0u) {}
+
+  void StartTest() override {
+    new_constraints_ = ParentCompositorDrawConstraints(
+        false, gfx::Transform(), gfx::Rect(window_->surface_size()));
+    new_constraints_.transform.Scale(2.0, 2.0);
+    browser_view_renderer_->SetContinuousInvalidate(true);
+  }
+
+  void WillOnDraw() override {
+    browser_view_renderer_->SetContinuousInvalidate(false);
+    // Step 0: A single onDraw on screen. The parent draw constraints
+    // of the BVR will updated to be the initial constraints.
+    // Step 1: A single onDrraw off screen. The parent draw constraints of the
+    // BVR will be updated to the new constraints.
+    // Step 2: This onDraw is to introduce the DrawGL that animates the
+    // webview onto the screen on render thread. End the test when the parent
+    // draw constraints of BVR is updated to initial constraints.
+    if (on_draw_count_ == 1u || on_draw_count_ == 2u)
+      browser_view_renderer_->PrepareToDraw(gfx::Vector2d(), gfx::Rect());
+  }
+
+  void DidOnDraw(bool success) override {
+    EXPECT_TRUE(success);
+    on_draw_count_++;
+  }
+
+  bool WillDrawOnRT(SharedRendererState* functor,
+                    AwDrawGLInfo* draw_info) override {
+    if (draw_gl_count_on_rt_ == 1u) {
+      draw_gl_count_on_rt_++;
+      ui_proxy_->PostTask(FROM_HERE, base::Bind(&RenderingTest::PostInvalidate,
+                                                base::Unretained(this)));
+      return false;
+    }
+
+    draw_info->width = window_->surface_size().width();
+    draw_info->height = window_->surface_size().height();
+    draw_info->is_layer = false;
+
+    gfx::Transform transform;
+    if (draw_gl_count_on_rt_ == 0u)
+      transform = new_constraints_.transform;
+
+    transform.matrix().asColMajorf(draw_info->transform);
+    return true;
+  }
+
+  void DidDrawOnRT(SharedRendererState* functor) override {
+    draw_gl_count_on_rt_++;
+  }
+
+  bool DrawConstraintsEquals(
+      const ParentCompositorDrawConstraints& constraints1,
+      const ParentCompositorDrawConstraints& constraints2) {
+    if (constraints1.is_layer != constraints2.is_layer ||
+        constraints1.transform != constraints2.transform)
+      return false;
+
+    return !constraints1.is_layer ||
+           constraints1.surface_rect == constraints2.surface_rect;
+  }
+
+  void ParentDrawConstraintsUpdated(
+      const ParentCompositorDrawConstraints& constraints) override {
+    switch (on_draw_count_) {
+      case 1u:
+        EXPECT_TRUE(DrawConstraintsEquals(constraints, new_constraints_));
+        break;
+      case 3u:
+        EXPECT_TRUE(DrawConstraintsEquals(constraints, initial_constraints_));
+        EndTest();
+        break;
+      // There will be a following 4th onDraw. But the hardware renderer won't
+      // post back the draw constraints in DrawGL because the constraints
+      // don't change.
+      default:
+        FAIL();
+    }
+  }
+
+ private:
+  size_t on_draw_count_;
+  size_t draw_gl_count_on_rt_;
+  ParentCompositorDrawConstraints initial_constraints_;
+  ParentCompositorDrawConstraints new_constraints_;
+};
+
+RENDERING_TEST_F(TestAnimateInAndOutOfScreen);
+
 }  // namespace android_webview

android_webview/browser/hardware_renderer.cc

@@ -205,6 +205,7 @@ void HardwareRenderer::DrawGL(bool stencil_enabled,
   transform.matrix().setColMajorf(draw_info->transform);
   transform.Translate(scroll_offset_.x(), scroll_offset_.y());
 
+  viewport_.SetSize(draw_info->width, draw_info->height);
   // Need to post the new transform matrix back to child compositor
   // because there is no onDraw during a Render Thread animation, and child
   // compositor might not have the tiles rasterized as the animation goes on.
@@ -218,7 +219,6 @@ void HardwareRenderer::DrawGL(bool stencil_enabled,
   if (!delegated_layer_.get())
     return;
 
-  viewport_.SetSize(draw_info->width, draw_info->height);
   layer_tree_host_->SetViewportSize(viewport_);
   clip_.SetRect(draw_info->clip_left,
                 draw_info->clip_top,

android_webview/browser/test/fake_window.cc

@@ -5,7 +5,6 @@
 #include "android_webview/browser/test/fake_window.h"
 
 #include "android_webview/browser/browser_view_renderer.h"
-#include "android_webview/public/browser/draw_gl.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
@@ -119,8 +118,8 @@ void FakeWindow::OnDrawHardware() {
   DCHECK(on_draw_hardware_pending_);
   on_draw_hardware_pending_ = false;
 
-  hooks_->WillOnDraw();
   view_->PrepareToDraw(gfx::Vector2d(), location_);
+  hooks_->WillOnDraw();
   bool success = view_->OnDrawHardware();
   hooks_->DidOnDraw(success);
   if (success) {
@@ -156,31 +155,10 @@ void FakeWindow::DrawFunctorOnRT(base::WaitableEvent* sync) {
   draw_info.clip_top = location.y();
   draw_info.clip_right = location.x() + location.width();
   draw_info.clip_bottom = location.y() + location.height();
-  draw_info.width = surface_size_.width();
-  draw_info.height = surface_size_.height();
-  draw_info.is_layer = false;
-
-  draw_info.transform[0] = 1.0;
-  draw_info.transform[1] = 0.0;
-  draw_info.transform[2] = 0.0;
-  draw_info.transform[3] = 0.0;
-
-  draw_info.transform[4] = 0.0;
-  draw_info.transform[5] = 1.0;
-  draw_info.transform[6] = 0.0;
-  draw_info.transform[7] = 0.0;
-
-  draw_info.transform[8] = 0.0;
-  draw_info.transform[9] = 0.0;
-  draw_info.transform[10] = 1.0;
-  draw_info.transform[11] = 0.0;
-
-  draw_info.transform[12] = 0.0;
-  draw_info.transform[13] = 0.0;
-  draw_info.transform[14] = 0.0;
-  draw_info.transform[15] = 1.0;
-
-  hooks_->WillDrawOnRT(functor_);
+
+  if (!hooks_->WillDrawOnRT(functor_, &draw_info))
+    return;
+
   {
     ScopedMakeCurrent make_current(this);
     functor_->DrawGL(&draw_info);

android_webview/browser/test/fake_window.h

@@ -7,6 +7,7 @@
 
 #include <map>
 
+#include "android_webview/public/browser/draw_gl.h"
 #include "base/memory/weak_ptr.h"
 #include "base/sequence_checker.h"
 #include "base/single_thread_task_runner.h"
@@ -35,7 +36,8 @@ class WindowHooks {
   virtual void DidSyncOnRT(SharedRendererState* functor) = 0;
   virtual void WillProcessOnRT(SharedRendererState* functor) = 0;
   virtual void DidProcessOnRT(SharedRendererState* functor) = 0;
-  virtual void WillDrawOnRT(SharedRendererState* functor) = 0;
+  virtual bool WillDrawOnRT(SharedRendererState* functor,
+                            AwDrawGLInfo* draw_info) = 0;
   virtual void DidDrawOnRT(SharedRendererState* functor) = 0;
 };
 
@@ -51,6 +53,7 @@ class FakeWindow {
   // BrowserViewRendererClient methods.
   void RequestDrawGL(bool wait_for_completion);
   void PostInvalidate();
+  const gfx::Size& surface_size() { return surface_size_; }
 
  private:
   class ScopedMakeCurrent;

android_webview/browser/test/rendering_test.cc

@@ -5,6 +5,7 @@
 #include "android_webview/browser/test/rendering_test.h"
 
 #include "android_webview/browser/browser_view_renderer.h"
+#include "android_webview/browser/child_frame.h"
 #include "base/message_loop/message_loop.h"
 #include "content/public/test/test_synchronous_compositor_android.h"
 
@@ -66,6 +67,16 @@ bool RenderingTest::RequestDrawGL(bool wait_for_completion) {
   return true;
 }
 
+bool RenderingTest::WillDrawOnRT(SharedRendererState* functor,
+                                 AwDrawGLInfo* draw_info) {
+  draw_info->width = window_->surface_size().width();
+  draw_info->height = window_->surface_size().height();
+  draw_info->is_layer = false;
+  gfx::Transform transform;
+  transform.matrix().asColMajorf(draw_info->transform);
+  return true;
+}
+
 void RenderingTest::OnNewPicture() {
 }
 

android_webview/browser/test/rendering_test.h

@@ -23,6 +23,7 @@ namespace android_webview {
 
 class BrowserViewRenderer;
 class FakeWindow;
+struct ParentCompositorDrawConstraints;
 
 class RenderingTest : public testing::Test,
                       public BrowserViewRendererClient,
@@ -42,7 +43,8 @@ class RenderingTest : public testing::Test,
                          float min_page_scale_factor,
                          float max_page_scale_factor) override {}
   void DidOverscroll(gfx::Vector2d overscroll_delta) override {}
-
+  void ParentDrawConstraintsUpdated(
+      const ParentCompositorDrawConstraints& draw_constraints) override {}
   // WindowHooks overrides.
   void WillOnDraw() override {}
   void DidOnDraw(bool success) override {}
@@ -50,7 +52,8 @@ class RenderingTest : public testing::Test,
   void DidSyncOnRT(SharedRendererState* functor) override {}
   void WillProcessOnRT(SharedRendererState* functor) override {}
   void DidProcessOnRT(SharedRendererState* functor) override {}
-  void WillDrawOnRT(SharedRendererState* functor) override {}
+  bool WillDrawOnRT(SharedRendererState* functor,
+                    AwDrawGLInfo* draw_info) override;
   void DidDrawOnRT(SharedRendererState* functor) override {}
 
  protected:

android_webview/native/aw_contents.h

@@ -205,6 +205,8 @@ class AwContents : public FindHelper::Listener,
                          float min_page_scale_factor,
                          float max_page_scale_factor) override;
   void DidOverscroll(gfx::Vector2d overscroll_delta) override;
+  void ParentDrawConstraintsUpdated(
+      const ParentCompositorDrawConstraints& draw_constraints) override {}
 
   void ClearCache(JNIEnv* env, jobject obj, jboolean include_disk_files);
   void SetPendingWebContentsForPopup(scoped_ptr<content::WebContents> pending);