Fix resourceless software draw

cc/trees/layer_tree_host_unittest.cc

Index: cc/trees/layer_tree_host_unittest.cc
diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc
index 51f0ff7b3cac55e747889ac044a26d2140b8acaa..6931b95bae164e949337a3ebd57706a5d19b1e41 100644
--- a/cc/trees/layer_tree_host_unittest.cc
+++ b/cc/trees/layer_tree_host_unittest.cc
@@ -2960,6 +2960,92 @@ class LayerTreeHostTestDeferredInitialize : public LayerTreeHostTest {
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestDeferredInitialize);
 
+class LayerTreeHostTestResourcelessSoftwareDraw : public LayerTreeHostTest {
+ public:
+  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_->SetForceRenderSurface(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();
+  }
+
+  scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface() override {
+    return FakeOutputSurface::CreateDeferredGL(
+        make_scoped_ptr(new SoftwareOutputDevice), delegating_renderer());
+  }
+
+  void BeginTest() override {
+    PostSetNeedsCommitToMainThread();
+    swap_count_ = 0;
+  }
+
+  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];
+      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 SwapBuffersCompleteOnThread(LayerTreeHostImpl* host_impl) override {
+    swap_count_++;
+    switch (swap_count_) {
+      case 1: {
+        gfx::Transform identity;
+        gfx::Rect empty_rect;
+        bool resourceless_software_draw = true;
+        host_impl->SetExternalDrawConstraints(identity, empty_rect, empty_rect,
+                                              empty_rect, identity,
+                                              resourceless_software_draw);
+        host_impl->SetFullRootLayerDamage();
+        host_impl->SetNeedsRedraw();
+        break;
+      }
+      case 2:
+        EndTest();
+        break;
+      default:
+        NOTREACHED();
+    }
+  }
+
+  void AfterTest() override {}
+
+ private:
+  FakeContentLayerClient client_;
+  scoped_refptr<Layer> root_layer_;
+  scoped_refptr<Layer> parent_layer_;
+  scoped_refptr<Layer> child_layer_;
+  int swap_count_;
+};
+
+MULTI_THREAD_IMPL_TEST_F(LayerTreeHostTestResourcelessSoftwareDraw);
+
 class LayerTreeHostTestDeferredInitializeWithGpuRasterization
     : public LayerTreeHostTestDeferredInitialize {
   void InitializeSettings(LayerTreeSettings* settings) override {