cc: Move draw params from SetExternalDrawConstraints to OnDraw

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 <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/location.h"
@@ skipping 2102 matching lines @@
         FROM_HERE,
         base::Bind(
             &LayerTreeHostTestAbortedCommitDoesntStallSynchronousCompositor::
                 CallOnDraw,
             base::Unretained(this)));
   }
 
   void CallOnDraw() {
     // Synchronous compositor does not draw unless told to do so by the output
     // surface.
-    output_surface()->client()->OnDraw();
+    gfx::Transform identity;
+    gfx::Rect empty_rect;
+    bool resourceless_software_draw = false;
+    output_surface()->client()->OnDraw(identity, empty_rect, empty_rect,
+                                       resourceless_software_draw);
   }
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostTestAbortedCommitDoesntStallSynchronousCompositor);
 
 class LayerTreeHostTestAbortedCommitDoesntStallDisabledVsync
     : public LayerTreeHostTestAbortedCommitDoesntStall {
   void InitializeSettings(LayerTreeSettings* settings) override {
     LayerTreeHostTestAbortedCommitDoesntStall::InitializeSettings(settings);
@@ skipping 281 matching lines @@
   void AfterTest() override {}
 
  protected:
   int frame_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestNumFramesPending);
 
 class LayerTreeHostTestResourcelessSoftwareDraw : public LayerTreeHostTest {
  public:
+  void InitializeSettings(LayerTreeSettings* settings) override {
+    settings->using_synchronous_renderer_compositor = true;
+  }
+
   void SetupTree() override {
     root_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     root_layer_->SetIsDrawable(true);
     root_layer_->SetBounds(gfx::Size(50, 50));
 
     parent_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     parent_layer_->SetIsDrawable(true);
     parent_layer_->SetBounds(gfx::Size(50, 50));
     parent_layer_->SetForceRenderSurface(true);
 
@@ skipping 17 matching lines @@
       return FakeOutputSurface::CreateSoftware(
           make_scoped_ptr(new SoftwareOutputDevice));
     }
   }
 
   void BeginTest() override {
     PostSetNeedsCommitToMainThread();
     swap_count_ = 0;
   }
 
+  void ScheduledActionInvalidateOutputSurface() override {
+    if (TestEnded())
+      return;
+
+    ImplThreadTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&LayerTreeHostTestResourcelessSoftwareDraw::CallOnDraw,
+                   base::Unretained(this)));
+  }
+
+  void CallOnDraw() {
+    gfx::Transform identity;
+    gfx::Rect empty_rect;
+    bool resourceless_software_draw = true;
+    output_surface()->client()->OnDraw(identity, empty_rect, empty_rect,
+                                       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 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();
+      case 1:
         host_impl->SetNeedsRedraw();
         break;
-      }
       case 2:
         EndTest();
         break;
       default:
         NOTREACHED();
     }
   }
 
   void AfterTest() override {}
 
@@ skipping 4040 matching lines @@
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPaintedDeviceScaleFactor);
 
 }  // namespace
 }  // namespace cc