Add a BrowserViewRenderer unittest for compositor switch logic

android_webview/browser/browser_view_renderer_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <map>
 #include <queue>
 #include <utility>
 
 #include "android_webview/browser/browser_view_renderer.h"
 #include "android_webview/browser/child_frame.h"
 #include "android_webview/browser/compositor_frame_consumer.h"
 #include "android_webview/browser/render_thread_manager.h"
 #include "android_webview/browser/test/rendering_test.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/output/compositor_frame.h"
 #include "content/public/test/test_synchronous_compositor_android.h"
 
 namespace android_webview {
 
 class SmokeTest : public RenderingTest {
   void StartTest() override {
-    browser_view_renderer_->PostInvalidate(compositor_.get());
+    browser_view_renderer_->PostInvalidate(ActiveCompositor());
   }
 
   void DidDrawOnRT() override { EndTest(); }
 };
 
 RENDERING_TEST_F(SmokeTest);
 
+// Test the case where SynchronousCompositor is constructed after the RVH that
+// owns it is switched to be active.
+class ActiveCompositorSwitchBeforeConstructionTest : public RenderingTest {
+ public:
+  ActiveCompositorSwitchBeforeConstructionTest()
+      : on_draw_count_(0), new_compositor_(nullptr) {}
+  void StartTest() override {
+    browser_view_renderer_->PostInvalidate(ActiveCompositor());
+  }
+
+  void DidOnDraw(bool success) override {
+    on_draw_count_++;
+    switch (on_draw_count_) {
+      case 1:
+        EXPECT_TRUE(success);
+        // Change compositor here. And do another ondraw.
+        // The previous active compositor id is 0, 0, now change it to 0, 1.
+        browser_view_renderer_->SetActiveCompositorID(CompositorID(0, 1));
+        browser_view_renderer_->PostInvalidate(ActiveCompositor());
+        break;
+      case 2:
+        // The 2nd ondraw is skipped because there is no active compositor at
+        // the moment.
+        EXPECT_FALSE(success);
+        new_compositor_.reset(new content::TestSynchronousCompositor(0, 1));
+        new_compositor_->SetClient(browser_view_renderer_.get());
+        EXPECT_EQ(ActiveCompositor(), new_compositor_.get());
+        browser_view_renderer_->PostInvalidate(ActiveCompositor());
+        break;
+      case 3:
+        EXPECT_TRUE(success);
+        compositor_ = std::move(new_compositor_);
+
+        EXPECT_EQ(ActiveCompositor(), compositor_.get());
+        browser_view_renderer_->PostInvalidate(ActiveCompositor());
+        break;
+      case 4:
+        EXPECT_TRUE(success);
+        EndTest();
+    }
+  }
+
+ private:
+  int on_draw_count_;
+  std::unique_ptr<content::TestSynchronousCompositor> new_compositor_;
+};
+
+RENDERING_TEST_F(ActiveCompositorSwitchBeforeConstructionTest);
+
+// Test the case where SynchronousCompositor is constructed before the RVH that
+// owns it is switched to be active.
+class ActiveCompositorSwitchAfterConstructionTest : public RenderingTest {
+ public:
+  ActiveCompositorSwitchAfterConstructionTest()
+      : on_draw_count_(0), new_compositor_(nullptr) {}
+  void StartTest() override {
+    browser_view_renderer_->PostInvalidate(ActiveCompositor());
+  }
+
+  void DidOnDraw(bool success) override {
+    on_draw_count_++;
+    switch (on_draw_count_) {
+      case 1:
+        EXPECT_TRUE(success);
+        // Create a new compositor here. And switch it to be active.  And then
+        // do another ondraw.
+        new_compositor_.reset(new content::TestSynchronousCompositor(0, 1));
+        new_compositor_->SetClient(browser_view_renderer_.get());
+        browser_view_renderer_->SetActiveCompositorID(CompositorID(0, 1));
+
+        EXPECT_EQ(ActiveCompositor(), new_compositor_.get());
+        browser_view_renderer_->PostInvalidate(ActiveCompositor());
+        break;
+      case 2:
+        EXPECT_TRUE(success);
+        compositor_ = std::move(new_compositor_);
+
+        EXPECT_EQ(ActiveCompositor(), compositor_.get());
+        browser_view_renderer_->PostInvalidate(ActiveCompositor());
+        break;
+      case 3:
+        EXPECT_TRUE(success);
+        EndTest();
+    }
+  }
+
+ private:
+  int on_draw_count_;
+  std::unique_ptr<content::TestSynchronousCompositor> new_compositor_;
+};
+
+RENDERING_TEST_F(ActiveCompositorSwitchAfterConstructionTest);
+
 class ClearViewTest : public RenderingTest {
  public:
   ClearViewTest() : on_draw_count_(0) {}
 
   void StartTest() override {
-    browser_view_renderer_->PostInvalidate(compositor_.get());
+    browser_view_renderer_->PostInvalidate(ActiveCompositor());
     browser_view_renderer_->ClearView();
   }
 
   void DidOnDraw(bool success) override {
     on_draw_count_++;
     if (on_draw_count_ == 1) {
       // First OnDraw should be skipped due to ClearView.
       EXPECT_FALSE(success);
       browser_view_renderer_->DidUpdateContent(
-          compositor_.get());  // Unset ClearView.
-      browser_view_renderer_->PostInvalidate(compositor_.get());
+          ActiveCompositor());  // Unset ClearView.
+      browser_view_renderer_->PostInvalidate(ActiveCompositor());
     } else {
       // Following OnDraws should succeed.
       EXPECT_TRUE(success);
     }
   }
 
   void DidDrawOnRT() override { EndTest(); }
 
  private:
   int on_draw_count_;
 };
 
 RENDERING_TEST_F(ClearViewTest);
 
 class TestAnimateInAndOutOfScreen : public RenderingTest {
  public:
   TestAnimateInAndOutOfScreen() : on_draw_count_(0), draw_gl_count_on_rt_(0) {}
 
   void StartTest() override {
     new_constraints_ = ParentCompositorDrawConstraints(
         false, gfx::Transform(), window_->surface_size().IsEmpty());
     new_constraints_.transform.Scale(2.0, 2.0);
-    browser_view_renderer_->PostInvalidate(compositor_.get());
+    browser_view_renderer_->PostInvalidate(ActiveCompositor());
   }
 
   void WillOnDraw() override {
     RenderingTest::WillOnDraw();
     // 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
@@ skipping 71 matching lines @@
   ParentCompositorDrawConstraints new_constraints_;
 };
 
 RENDERING_TEST_F(TestAnimateInAndOutOfScreen);
 
 class CompositorNoFrameTest : public RenderingTest {
  public:
   CompositorNoFrameTest() : on_draw_count_(0) {}
 
   void StartTest() override {
-    browser_view_renderer_->PostInvalidate(compositor_.get());
+    browser_view_renderer_->PostInvalidate(ActiveCompositor());
   }
 
   void WillOnDraw() override {
     if (0 == on_draw_count_) {
       // No frame from compositor.
     } else if (1 == on_draw_count_) {
       compositor_->SetHardwareFrame(0u, ConstructEmptyFrame());
     } else if (2 == on_draw_count_) {
       // No frame from compositor.
     }
     // There may be trailing invalidates.
   }
 
   void DidOnDraw(bool success) override {
     if (0 == on_draw_count_) {
       // Should fail as there has been no frames from compositor.
       EXPECT_FALSE(success);
-      browser_view_renderer_->PostInvalidate(compositor_.get());
+      browser_view_renderer_->PostInvalidate(ActiveCompositor());
     } else if (1 == on_draw_count_) {
       // Should succeed with frame from compositor.
       EXPECT_TRUE(success);
-      browser_view_renderer_->PostInvalidate(compositor_.get());
+      browser_view_renderer_->PostInvalidate(ActiveCompositor());
     } else if (2 == on_draw_count_) {
       // Should still succeed with last frame, even if no frame from compositor.
       EXPECT_TRUE(success);
       EndTest();
     }
     on_draw_count_++;
   }
 
  private:
   int on_draw_count_;
@@ skipping 42 matching lines @@
     }
     return counts;
   }
 
   virtual void CheckResults() = 0;
 
  private:
   bool AdvanceFrame() {
     next_frame_ = GetFrame(frame_number_++);
     if (next_frame_) {
-      browser_view_renderer_->PostInvalidate(compositor_.get());
+      browser_view_renderer_->PostInvalidate(ActiveCompositor());
       return true;
     }
     return false;
   }
 
   std::unique_ptr<content::SynchronousCompositor::Frame> next_frame_;
   int frame_number_;
 };
 
 class SwitchOutputSurfaceIdTest : public ResourceRenderingTest {
@@ skipping 140 matching lines @@
   }
 
  private:
   std::unique_ptr<FakeFunctor> saved_functor_;
   OutputSurfaceResourceCountMap expected_return_count_;
 };
 
 RENDERING_TEST_F(RenderThreadManagerSwitchTest);
 
 }  // namespace android_webview