WIP Handle AwContents needing multiple live functors.

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/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(); }
 
   void DidDrawOnRT() override { EndTest(); }
 };
@@ skipping 90 matching lines @@
       return false;
 
     return !constraints1.is_layer ||
            constraints1.surface_rect_empty == constraints2.surface_rect_empty;
   }
 
   void OnParentDrawConstraintsUpdated() override {
     ParentCompositorDrawConstraints constraints =
         GetCompositorFrameConsumer()->GetParentDrawConstraintsOnUI();
     switch (on_draw_count_) {
+      case 0u:
+        EXPECT_TRUE(DrawConstraintsEquals(constraints, initial_constraints_));
+        break;
       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.
@@ skipping 105 matching lines @@
       return true;
     }
     return false;
   }
 
   std::unique_ptr<content::SynchronousCompositor::Frame> next_frame_;
   int frame_number_;
 };
 
 class SwitchOutputSurfaceIdTest : public ResourceRenderingTest {
+ public:

[boliu, 2016/05/10 15:18:19]

are these new public calls needed? Are there subclasses?

[Tobias Sargeant, 2016/05/13 13:23:56]

No they don't need to be; I was just aligning these test classes with the form
of others higher up in the file. Removed.

   struct FrameInfo {
     uint32_t output_surface_id;
     cc::ResourceId resource_id;  // Each frame contains a single resource.
   };
 
   std::unique_ptr<content::SynchronousCompositor::Frame> GetFrame(
       int frame_number) override {
     static const FrameInfo infos[] = {
         // First output surface.
         {0u, 1u},
@@ skipping 46 matching lines @@
   }
 
  private:
   uint32_t last_output_surface_id_;
   ResourceCountMap expected_return_count_;
 };
 
 RENDERING_TEST_F(SwitchOutputSurfaceIdTest);
 
 class RenderThreadManagerDeletionTest : public ResourceRenderingTest {
+ public:
   std::unique_ptr<content::SynchronousCompositor::Frame> GetFrame(
       int frame_number) override {
     if (frame_number > 0) {
       return nullptr;
     }
 
     const uint32_t output_surface_id = 0u;
     const cc::ResourceId resource_id =
         static_cast<cc::ResourceId>(frame_number);
 
     std::unique_ptr<content::SynchronousCompositor::Frame> frame(
         new content::SynchronousCompositor::Frame);
     frame->output_surface_id = output_surface_id;
     frame->frame = ConstructFrame(resource_id);
     ++expected_return_count_[output_surface_id][resource_id];
     return frame;
   }
 
   void CheckResults() override {
     OutputSurfaceResourceCountMap resource_counts;
-    render_thread_manager_.reset();
+    functor_.reset();
     // Make sure resources for the last frame are returned.
     EXPECT_EQ(expected_return_count_, GetReturnedResourceCounts());
     EndTest();
   }
 
  private:
   OutputSurfaceResourceCountMap expected_return_count_;
 };
 
 RENDERING_TEST_F(RenderThreadManagerDeletionTest);
 
+class RenderThreadManagerSwitchTest : public ResourceRenderingTest {
+ public:
+  std::unique_ptr<content::SynchronousCompositor::Frame> GetFrame(
+      int frame_number) override {
+    switch (frame_number) {
+      case 0:
+        // Draw a frame with initial RTM.
+        break;
+      case 1:
+        // Switch to new RTM.
+        saved_functor_ = std::move(functor_);
+        functor_.reset(
+            new Functor(base::Bind(&RenderingTest::CreateRenderThreadManager,
+                                   base::Unretained(this))));
+        browser_view_renderer_->SetCurrentCompositorFrameConsumer(
+            functor_->GetCompositorFrameConsumer());
+        window_->SetDrawFunctor(functor_.get());
+        break;
+      case 2:
+        // Draw a frame with the new RTM, but also redraw the initial RTM.
+        window_->RequestDrawGL(saved_functor_.get());
+        break;
+      case 3:
+        // Switch back to the initial RTM, allowing the new RTM to be destroyed.
+        functor_ = std::move(saved_functor_);
+        browser_view_renderer_->SetCurrentCompositorFrameConsumer(
+            functor_->GetCompositorFrameConsumer());
+        window_->SetDrawFunctor(functor_.get());
+        break;
+      default:
+        return nullptr;
+    }
+
+    const uint32_t output_surface_id = 0u;
+    const cc::ResourceId resource_id =
+        static_cast<cc::ResourceId>(frame_number);
+
+    std::unique_ptr<content::SynchronousCompositor::Frame> frame(
+        new content::SynchronousCompositor::Frame);
+    frame->output_surface_id = output_surface_id;
+    frame->frame = ConstructFrame(resource_id);
+    ++expected_return_count_[output_surface_id][resource_id];
+    return frame;
+  }
+
+  void CheckResults() override {
+    OutputSurfaceResourceCountMap resource_counts;
+    functor_.reset();
+    // Make sure resources for all frames are returned.
+    EXPECT_EQ(expected_return_count_, GetReturnedResourceCounts());
+    EndTest();
+  }
+
+ private:
+  std::unique_ptr<Functor> saved_functor_;
+  OutputSurfaceResourceCountMap expected_return_count_;
+};
+
+RENDERING_TEST_F(RenderThreadManagerSwitchTest);
+
 }  // namespace android_webview