Test: deleting RTM before BVR does not leak resources.

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/test/rendering_test.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.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(); }
 
-  void DidDrawOnRT(RenderThreadManager* functor) override {
-    EndTest();
-  }
+  void DidDrawOnRT() override { EndTest(); }
 };
 
 RENDERING_TEST_F(SmokeTest);
 
 class ClearViewTest : public RenderingTest {
  public:
   ClearViewTest() : on_draw_count_(0) {}
 
   void StartTest() override {
     browser_view_renderer_->PostInvalidate();
     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();  // Unset ClearView.
       browser_view_renderer_->PostInvalidate();
     } else {
       // Following OnDraws should succeed.
       EXPECT_TRUE(success);
     }
   }
 
-  void DidDrawOnRT(RenderThreadManager* functor) override {
-    EndTest();
-  }
+  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) {}
 
@@ skipping 15 matching lines @@
     // draw constraints of BVR is updated to initial constraints.
     if (on_draw_count_ == 1 || on_draw_count_ == 2)
       browser_view_renderer_->PrepareToDraw(gfx::Vector2d(), gfx::Rect());
   }
 
   void DidOnDraw(bool success) override {
     EXPECT_TRUE(success);
     on_draw_count_++;
   }
 
-  bool WillDrawOnRT(RenderThreadManager* functor,
-                    AwDrawGLInfo* draw_info) override {
+  bool WillDrawOnRT(AwDrawGLInfo* draw_info) override {
     if (draw_gl_count_on_rt_ == 1) {
       draw_gl_count_on_rt_++;
       ui_task_runner_->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_ == 0)
       transform = new_constraints_.transform;
 
     transform.matrix().asColMajorf(draw_info->transform);
     return true;
   }
 
-  void DidDrawOnRT(RenderThreadManager* functor) override {
-    draw_gl_count_on_rt_++;
-  }
+  void DidDrawOnRT() 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_empty == constraints2.surface_rect_empty;
@@ skipping 121 matching lines @@
       ui_task_runner_->PostTask(
           FROM_HERE, base::Bind(&SwitchOutputSurfaceIdTest::CheckResults,
                                 base::Unretained(this)));
     } else {
       frames_.pop();
       browser_view_renderer_->PostInvalidate();
     }
   }
 
   void CheckResults() {
+    GetCompositorFrameConsumer()->DeleteHardwareRendererOnUI();
     window_->Detach();
     window_.reset();
 
     // Make sure resources for the last output surface are returned.
     content::TestSynchronousCompositor::FrameAckArray returned_resources_array;
     compositor_->SwapReturnedResources(&returned_resources_array);
     for (const auto& resources : returned_resources_array) {
       if (resources.output_surface_id != last_output_surface_id_)
         continue;
       for (const auto& returned_resource : resources.resources) {
@@ skipping 13 matching lines @@
 
  private:
   std::queue<content::SynchronousCompositor::Frame> frames_;
   uint32_t last_output_surface_id_;
   std::map<cc::ResourceId, int> expected_return_count_;
 };
 
 RENDERING_TEST_F(SwitchOutputSurfaceIdTest);
 
 }  // namespace android_webview