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:
+        // This OnParentDrawConstraintsUpdated is generated by
+        // connecting the compositor frame consumer to the producer.
+        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 114 matching lines @@
 class SwitchOutputSurfaceIdTest : public ResourceRenderingTest {
   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},
-        {0u, 1u},
-        {0u, 2u},
-        {0u, 2u},
-        {0u, 3u},
-        {0u, 3u},
-        {0u, 4u},
+        {0u, 1u}, {0u, 1u}, {0u, 2u}, {0u, 2u}, {0u, 3u}, {0u, 3u}, {0u, 4u},
         // Second output surface.
-        {1u, 1u},
-        {1u, 1u},
-        {1u, 2u},
-        {1u, 2u},
-        {1u, 3u},
-        {1u, 3u},
-        {1u, 4u},
+        {1u, 1u}, {1u, 1u}, {1u, 2u}, {1u, 2u}, {1u, 3u}, {1u, 3u}, {1u, 4u},
     };
     if (frame_number >= static_cast<int>(arraysize(infos))) {
       return nullptr;
     }
 
     std::unique_ptr<content::SynchronousCompositor::Frame> frame(
         new content::SynchronousCompositor::Frame);
     frame->output_surface_id = infos[frame_number].output_surface_id;
     frame->frame = ConstructFrame(infos[frame_number].resource_id);
 
@@ skipping 42 matching lines @@
     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 {
+  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.
+        std::unique_ptr<FakeFunctor> functor(new FakeFunctor);
+        functor->Init(
+            window_.get(),
+            std::unique_ptr<RenderThreadManager>(new RenderThreadManager(

[boliu, 2016/05/13 16:09:01]

use base::WrapUnique

[Tobias Sargeant, 2016/05/13 17:02:36]

Done.

+                functor.get(), base::ThreadTaskRunnerHandle::Get())));
+        browser_view_renderer_->SetCurrentCompositorFrameConsumer(
+            functor->GetCompositorFrameConsumer());
+        saved_functor_ = std::move(functor_);
+        functor_ = std::move(functor);
+        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());
+        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<FakeFunctor> saved_functor_;
+  OutputSurfaceResourceCountMap expected_return_count_;
+};
+
+RENDERING_TEST_F(RenderThreadManagerSwitchTest);
+
 }  // namespace android_webview