cc: Enable use of render surfaces for Android WebView

cc/trees/layer_tree_host_unittest.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 3130 matching lines @@
   }
 
   void AfterTest() override {}
 
  protected:
   int frame_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestNumFramesPending);
 
-class LayerTreeHostTestResourcelessSoftwareDraw : public LayerTreeHostTest {
- protected:
-  void InitializeSettings(LayerTreeSettings* settings) override {
-    settings->using_synchronous_renderer_compositor = true;
-  }
-
-  void SetupTree() override {
-    root_layer_ = FakePictureLayer::Create(&client_);
-    root_layer_->SetIsDrawable(true);
-    root_layer_->SetBounds(gfx::Size(50, 50));
-
-    parent_layer_ = FakePictureLayer::Create(&client_);
-    parent_layer_->SetIsDrawable(true);
-    parent_layer_->SetBounds(gfx::Size(50, 50));
-    parent_layer_->SetForceRenderSurfaceForTesting(true);
-
-    child_layer_ = FakePictureLayer::Create(&client_);
-    child_layer_->SetIsDrawable(true);
-    child_layer_->SetBounds(gfx::Size(50, 50));
-
-    root_layer_->AddChild(parent_layer_);
-    parent_layer_->AddChild(child_layer_);
-    layer_tree_host()->SetRootLayer(root_layer_);
-
-    LayerTreeHostTest::SetupTree();
-    client_.set_bounds(root_layer_->bounds());
-  }
-
-  std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
-      scoped_refptr<ContextProvider> compositor_context_provider,
-      scoped_refptr<ContextProvider> worker_context_provider) override {
-    auto on_draw_callback =
-        base::Bind(&LayerTreeHostTestResourcelessSoftwareDraw::CallOnDraw,
-                   base::Unretained(this));
-    auto frame_sink = base::MakeUnique<OnDrawCompositorFrameSink>(
-        compositor_context_provider, std::move(worker_context_provider),
-        shared_bitmap_manager(), gpu_memory_buffer_manager(),
-        layer_tree_host()->GetSettings().renderer_settings,
-        ImplThreadTaskRunner(), false /* synchronous_composite */,
-        false /* force_disable_reclaim_resources */,
-        std::move(on_draw_callback));
-    compositor_frame_sink_ = frame_sink.get();
-    return std::move(frame_sink);
-  }
-
-  void BeginTest() override { PostSetNeedsCommitToMainThread(); }
-
-  void CallOnDraw() {
-    if (!TestEnded()) {
-      // Synchronous compositor does not draw unless told to do so by the output
-      // surface. But it needs to be done on a new stack frame.
-      bool resourceless_software_draw = true;
-      ImplThreadTaskRunner()->PostTask(
-          FROM_HERE, base::Bind(&OnDrawCompositorFrameSink::OnDraw,
-                                base::Unretained(compositor_frame_sink_),
-                                resourceless_software_draw));
-    }
-  }
-
-  DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
-                                   LayerTreeHostImpl::FrameData* frame_data,
-                                   DrawResult draw_result) override {
-    if (host_impl->GetDrawMode() == DRAW_MODE_RESOURCELESS_SOFTWARE) {
-      EXPECT_EQ(1u, frame_data->render_passes.size());
-      // Has at least 3 quads for each layer.
-      RenderPass* render_pass = frame_data->render_passes[0].get();
-      EXPECT_GE(render_pass->quad_list.size(), 3u);
-    } else {
-      EXPECT_EQ(2u, frame_data->render_passes.size());
-
-      // At least root layer quad in root render pass.
-      EXPECT_GE(frame_data->render_passes[0]->quad_list.size(), 1u);
-      // At least parent and child layer quads in parent render pass.
-      EXPECT_GE(frame_data->render_passes[1]->quad_list.size(), 2u);
-    }
-    return draw_result;
-  }
-
-  void DrawLayersOnThread(LayerTreeHostImpl* host_impl) override {
-    draw_count_++;
-    switch (draw_count_) {
-      case 1:
-        host_impl->SetNeedsRedraw();
-        break;
-      case 2:
-        EndTest();
-        break;
-      default:
-        NOTREACHED();
-    }
-  }
-
-  void AfterTest() override {}
-
- private:
-  OnDrawCompositorFrameSink* compositor_frame_sink_ = nullptr;
-  FakeContentLayerClient client_;
-  scoped_refptr<Layer> root_layer_;
-  scoped_refptr<Layer> parent_layer_;
-  scoped_refptr<Layer> child_layer_;
-  int draw_count_ = 0;
-};
-
-// Resourceless is not used for SingleThreadProxy, so it is unimplemented.
-MULTI_THREAD_TEST_F(LayerTreeHostTestResourcelessSoftwareDraw);
-
 // Test for UI Resource management.
 class LayerTreeHostTestUIResource : public LayerTreeHostTest {
  public:
   LayerTreeHostTestUIResource() : num_ui_resources_(0) {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
     settings->renderer_settings.texture_id_allocation_chunk_size = 1;
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
@@ skipping 3850 matching lines @@
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSubmitFrameResources);
 
 }  // namespace
 }  // namespace cc