cc: Move draw params from SetExternalDrawConstraints to OnDraw

cc/trees/layer_tree_host_impl_unittest.cc

Index: cc/trees/layer_tree_host_impl_unittest.cc
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index ca513c0848a0927b1ab3bbdc0efd5950663609ed..f5a9461007053ab60289bdaa05c3cd67fc9ed17c 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -6,6 +6,7 @@
 
 #include <algorithm>
 #include <cmath>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ -117,7 +118,6 @@ class LayerTreeHostImplTest : public testing::Test,
   void SetEstimatedParentDrawTime(base::TimeDelta draw_time) override {}
   void DidSwapBuffersOnImplThread() override {}
   void DidSwapBuffersCompleteOnImplThread() override {}
-  void OnResourcelessSoftareDrawStateChanged(bool resourceless_draw) override {}
   void OnCanDrawStateChanged(bool can_draw) override {
     on_can_draw_state_changed_called_ = true;
   }
@@ -153,7 +153,15 @@ class LayerTreeHostImplTest : public testing::Test,
   void DidCompletePageScaleAnimationOnImplThread() override {
     did_complete_page_scale_animation_ = true;
   }
-  void OnDrawForOutputSurface() override {}
+  void OnDrawForOutputSurface(bool resourceless_software_draw) override {
+    scoped_ptr<LayerTreeHostImpl::FrameData> frame(
+        new LayerTreeHostImpl::FrameData);
+    EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(frame.get()));
+    host_impl_->DrawLayers(frame.get());
+    host_impl_->DidDrawAllLayers(*frame);
+    host_impl_->SwapBuffers(*frame);
+    last_on_draw_frame_ = std::move(frame);
+  }
   void PostFrameTimingEventsOnImplThread(
       scoped_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
       scoped_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events)
@@ -456,6 +464,7 @@ class LayerTreeHostImplTest : public testing::Test,
   bool reduce_memory_result_;
   base::Closure animation_task_;
   base::TimeDelta requested_animation_delay_;
+  scoped_ptr<LayerTreeHostImpl::FrameData> last_on_draw_frame_;
 };
 
 // A test fixture for new animation timelines tests.
@@ -477,13 +486,8 @@ TEST_F(LayerTreeHostImplTest, CanDrawIncompleteFrames) {
   CreateHostImpl(DefaultSettings(),
                  FakeOutputSurface::CreateSoftware(
                      make_scoped_ptr(new SoftwareOutputDevice())));
-  const gfx::Transform external_transform;
-  const gfx::Rect external_viewport;
-  const gfx::Rect external_clip;
   const bool resourceless_software_draw = true;
-  host_impl_->SetExternalDrawConstraints(
-      external_transform, external_viewport, external_clip, external_viewport,
-      external_transform, resourceless_software_draw);
+  host_impl_->SetResourcelessSoftwareDrawForTesting(resourceless_software_draw);
 
   bool always_draw = true;
   CheckNotifyCalledIfCanDrawChanged(always_draw);
@@ -3382,9 +3386,8 @@ TEST_F(LayerTreeHostImplTest,
   const gfx::Rect external_viewport;
   const gfx::Rect external_clip;
   const bool resourceless_software_draw = true;
-  host_impl_->SetExternalDrawConstraints(
-      external_transform, external_viewport, external_clip, external_viewport,
-      external_transform, resourceless_software_draw);
+  host_impl_->SetExternalTilePriorityConstraints(external_viewport,
+                                                 external_transform);
 
   std::vector<PrepareToDrawSuccessTestCase> cases;
 
@@ -3409,11 +3412,8 @@ TEST_F(LayerTreeHostImplTest,
       static_cast<DidDrawCheckLayer*>(host_impl_->active_tree()->root_layer());
   root->SetForceRenderSurface(true);
 
-  LayerTreeHostImpl::FrameData frame;
-  EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
-  host_impl_->DrawLayers(&frame);
-  host_impl_->DidDrawAllLayers(frame);
-  host_impl_->SwapBuffers(frame);
+  host_impl_->OnDraw(external_transform, external_viewport, external_clip,
+                     resourceless_software_draw);
 
   for (size_t i = 0; i < cases.size(); ++i) {
     const auto& testcase = cases[i];
@@ -3457,11 +3457,8 @@ TEST_F(LayerTreeHostImplTest,
     if (testcase.high_res_required)
       host_impl_->SetRequiresHighResToDraw();
 
-    LayerTreeHostImpl::FrameData frame;
-    EXPECT_EQ(testcase.expected_result, PrepareToDrawFrame(&frame));
-    host_impl_->DrawLayers(&frame);
-    host_impl_->DidDrawAllLayers(frame);
-    host_impl_->SwapBuffers(frame);
+    host_impl_->OnDraw(external_transform, external_viewport, external_clip,
+                       resourceless_software_draw);
   }
 }
 
@@ -5960,13 +5957,9 @@ class LayerTreeHostImplViewportCoveredTest : public LayerTreeHostImplTest {
   }
 
   void SetResourcelessSoftwareDraw() {
-    const gfx::Transform external_transform;
-    const gfx::Rect external_viewport;
-    const gfx::Rect external_clip;
     const bool resourceless_software_draw = true;

[danakj, 2015/12/10 22:33:54]

if you wanted.. you could just pass |true| directly here now, there's only 1
variable and the name of the method says what it is now

-    host_impl_->SetExternalDrawConstraints(
-        external_transform, external_viewport, external_clip, external_viewport,
-        external_transform, resourceless_software_draw);
+    host_impl_->SetResourcelessSoftwareDrawForTesting(
+        resourceless_software_draw);
   }
 
   DrawQuad::Material gutter_quad_material_;
@@ -6010,7 +6003,6 @@ TEST_F(LayerTreeHostImplViewportCoveredTest, ActiveTreeGrowViewportInvalid) {
 
   bool software = true;
   CreateHostImpl(DefaultSettings(), CreateFakeOutputSurface(software));
-  SetResourcelessSoftwareDraw();
 
   // Pending tree to force active_tree size invalid. Not used otherwise.
   host_impl_->CreatePendingTree();
@@ -6018,6 +6010,7 @@ TEST_F(LayerTreeHostImplViewportCoveredTest, ActiveTreeGrowViewportInvalid) {
   EXPECT_TRUE(host_impl_->active_tree()->ViewportSizeInvalid());
 
   SetupActiveTreeLayers();
+  SetResourcelessSoftwareDraw();  // Needed to draw while viewport invalid.
   TestEmptyLayer();
   TestLayerInMiddleOfViewport();
   TestLayerIsLargerThanViewport();
@@ -6028,7 +6021,6 @@ TEST_F(LayerTreeHostImplViewportCoveredTest, ActiveTreeShrinkViewportInvalid) {
 
   bool software = true;
   CreateHostImpl(DefaultSettings(), CreateFakeOutputSurface(software));
-  SetResourcelessSoftwareDraw();
 
   // Set larger viewport and activate it to active tree.
   host_impl_->CreatePendingTree();
@@ -6046,6 +6038,7 @@ TEST_F(LayerTreeHostImplViewportCoveredTest, ActiveTreeShrinkViewportInvalid) {
   EXPECT_TRUE(host_impl_->active_tree()->ViewportSizeInvalid());
 
   SetupActiveTreeLayers();
+  SetResourcelessSoftwareDraw();  // Needed to draw while viewport invalid.
   TestEmptyLayer();
   TestLayerInMiddleOfViewport();
   TestLayerIsLargerThanViewport();
@@ -6856,17 +6849,14 @@ TEST_F(LayerTreeHostImplTest, ForcedDrawToSoftwareDeviceBasicRender) {
   const gfx::Rect external_viewport;
   const gfx::Rect external_clip;
   const bool resourceless_software_draw = true;
-  host_impl_->SetExternalDrawConstraints(external_transform,
-                                         external_viewport,
-                                         external_clip,
-                                         external_viewport,
-                                         external_transform,
-                                         resourceless_software_draw);
+  host_impl_->SetExternalTilePriorityConstraints(external_viewport,
+                                                 external_transform);
 
   EXPECT_EQ(0, software_device->frames_began_);
   EXPECT_EQ(0, software_device->frames_ended_);
 
-  DrawFrame();
+  host_impl_->OnDraw(external_transform, external_viewport, external_clip,
+                     resourceless_software_draw);
 
   EXPECT_EQ(1, software_device->frames_began_);
   EXPECT_EQ(1, software_device->frames_ended_);
@@ -6888,12 +6878,8 @@ TEST_F(LayerTreeHostImplTest,
   const gfx::Rect external_viewport;
   const gfx::Rect external_clip;
   const bool resourceless_software_draw = true;
-  host_impl_->SetExternalDrawConstraints(external_transform,
-                                         external_viewport,
-                                         external_clip,
-                                         external_viewport,
-                                         external_transform,
-                                         resourceless_software_draw);
+  host_impl_->SetExternalTilePriorityConstraints(external_viewport,
+                                                 external_transform);
 
   // SolidColorLayerImpl will be drawn.
   scoped_ptr<SolidColorLayerImpl> root_layer =
@@ -6908,13 +6894,12 @@ TEST_F(LayerTreeHostImplTest,
   root_layer->AddChild(std::move(video_layer));
   SetupRootLayerImpl(std::move(root_layer));
 
-  LayerTreeHostImpl::FrameData frame;
-  EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
-  host_impl_->DrawLayers(&frame);
-  host_impl_->DidDrawAllLayers(frame);
+  host_impl_->OnDraw(external_transform, external_viewport, external_clip,
+                     resourceless_software_draw);
 
-  EXPECT_EQ(1u, frame.will_draw_layers.size());
-  EXPECT_EQ(host_impl_->active_tree()->root_layer(), frame.will_draw_layers[0]);
+  EXPECT_EQ(1u, last_on_draw_frame_->will_draw_layers.size());
+  EXPECT_EQ(host_impl_->active_tree()->root_layer(),
+            last_on_draw_frame_->will_draw_layers[0]);
 }
 
 // Checks that we have a non-0 default allocation if we pass a context that
@@ -8436,24 +8421,18 @@ TEST_F(LayerTreeHostImplTest, ExternalTransformReflectedInNextDraw) {
   LayerImpl* layer = SetupScrollAndContentsLayers(layer_size);
   layer->SetDrawsContent(true);
 
-  host_impl_->SetExternalDrawConstraints(external_transform,
-                                         external_viewport,
-                                         external_clip,
-                                         external_viewport,
-                                         external_transform,
-                                         resourceless_software_draw);
-  DrawFrame();
+  host_impl_->SetExternalTilePriorityConstraints(external_viewport,
+                                                 external_transform);
+  host_impl_->OnDraw(external_transform, external_viewport, external_clip,
+                     resourceless_software_draw);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       external_transform, layer->draw_properties().target_space_transform);
 
   external_transform.Translate(20, 20);
-  host_impl_->SetExternalDrawConstraints(external_transform,
-                                         external_viewport,
-                                         external_clip,
-                                         external_viewport,
-                                         external_transform,
-                                         resourceless_software_draw);
-  DrawFrame();
+  host_impl_->SetExternalTilePriorityConstraints(external_viewport,
+                                                 external_transform);
+  host_impl_->OnDraw(external_transform, external_viewport, external_clip,
+                     resourceless_software_draw);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       external_transform, layer->draw_properties().target_space_transform);
 }
@@ -8461,66 +8440,103 @@ TEST_F(LayerTreeHostImplTest, ExternalTransformReflectedInNextDraw) {
 TEST_F(LayerTreeHostImplTest, ExternalTransformSetNeedsRedraw) {
   SetupRootLayerImpl(LayerImpl::Create(host_impl_->active_tree(), 1));
 
-  const gfx::Size layer_size(100, 100);
-  const gfx::Transform external_transform;
-  const gfx::Rect external_viewport(layer_size);
-  const gfx::Rect external_clip1(layer_size);
-  const gfx::Rect external_clip2(50, 50);
+  const gfx::Size viewport_size(100, 100);
+  host_impl_->SetViewportSize(viewport_size);
+
+  const gfx::Transform transform_for_tile_priority;
+  const gfx::Transform draw_transform;
+  const gfx::Rect viewport_for_tile_priority1(viewport_size);
+  const gfx::Rect viewport_for_tile_priority2(50, 50);
+  const gfx::Rect draw_viewport(viewport_size);
+  const gfx::Rect clip(viewport_size);
   bool resourceless_software_draw = false;
 
-  resourceless_software_draw = false;
-  host_impl_->SetExternalDrawConstraints(
-      external_transform, external_viewport, external_clip1, external_viewport,
-      external_transform, resourceless_software_draw);
-  {
-    // Clear any damage.
-    LayerTreeHostImpl::FrameData frame;
-    EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
-    host_impl_->DrawLayers(&frame);
-    host_impl_->DidDrawAllLayers(frame);
-    host_impl_->SwapBuffers(frame);
-  }
+  // Clear any damage.
+  host_impl_->SetExternalTilePriorityConstraints(viewport_for_tile_priority1,
+                                                 transform_for_tile_priority);
+  host_impl_->OnDraw(draw_transform, draw_viewport, clip,
+                     resourceless_software_draw);
+  last_on_draw_frame_.reset();
 
   // Setting new constraints needs redraw.
   did_request_redraw_ = false;
-  host_impl_->SetExternalDrawConstraints(
-      external_transform, external_viewport, external_clip2, external_viewport,
-      external_transform, resourceless_software_draw);
+  host_impl_->SetExternalTilePriorityConstraints(viewport_for_tile_priority2,
+                                                 transform_for_tile_priority);
   EXPECT_TRUE(did_request_redraw_);
-  {
-    LayerTreeHostImpl::FrameData frame;
-    EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
-    EXPECT_FALSE(frame.has_no_damage);
-    host_impl_->DrawLayers(&frame);
-    host_impl_->DidDrawAllLayers(frame);
-    host_impl_->SwapBuffers(frame);
-  }
+  host_impl_->OnDraw(draw_transform, draw_viewport, clip,
+                     resourceless_software_draw);
+  EXPECT_FALSE(last_on_draw_frame_->has_no_damage);
+}
+
+TEST_F(LayerTreeHostImplTest, OnDrawConstraintSetNeedsRedraw) {
+  SetupRootLayerImpl(LayerImpl::Create(host_impl_->active_tree(), 1));
+
+  const gfx::Size viewport_size(100, 100);
+  host_impl_->SetViewportSize(viewport_size);
 
-  // Resourceless software draw toggles do not need redraw. Damage is
-  // set externally by SynchronousCompositorOutputSurface in this case.
+  const gfx::Transform draw_transform;
+  const gfx::Rect draw_viewport1(viewport_size);
+  const gfx::Rect draw_viewport2(50, 50);
+  const gfx::Rect clip(viewport_size);
+  bool resourceless_software_draw = false;
 
-  // Setting resourceless_software_draw do not need redraw.
+  // Clear any damage.
+  host_impl_->OnDraw(draw_transform, draw_viewport1, clip,
+                     resourceless_software_draw);
+  last_on_draw_frame_.reset();
+
+  // Same draw params does not swap.
   did_request_redraw_ = false;
-  resourceless_software_draw = true;
-  host_impl_->SetExternalDrawConstraints(
-      external_transform, external_viewport, external_clip1, external_viewport,
-      external_transform, resourceless_software_draw);
+  host_impl_->OnDraw(draw_transform, draw_viewport1, clip,
+                     resourceless_software_draw);
   EXPECT_FALSE(did_request_redraw_);
-  // Can't call PrepareToDrawFrame with no change for resourceless software
-  // draw.
+  EXPECT_TRUE(last_on_draw_frame_->has_no_damage);
+  last_on_draw_frame_.reset();
 
-  // Unsetting resourceless_software_draw do not need redraw.
+  // Different draw params does swap.
   did_request_redraw_ = false;
-  resourceless_software_draw = false;
-  host_impl_->SetExternalDrawConstraints(
-      external_transform, external_viewport, external_clip2, external_viewport,
-      external_transform, resourceless_software_draw);
-  EXPECT_FALSE(did_request_redraw_);
-  {
-    LayerTreeHostImpl::FrameData frame;
-    EXPECT_EQ(DRAW_SUCCESS, PrepareToDrawFrame(&frame));
-    EXPECT_TRUE(frame.has_no_damage);
+  host_impl_->OnDraw(draw_transform, draw_viewport2, clip,
+                     resourceless_software_draw);
+  EXPECT_TRUE(did_request_redraw_);
+  EXPECT_FALSE(last_on_draw_frame_->has_no_damage);
+}
+
+class ResourcelessSoftwareLayerTreeHostImplTest : public LayerTreeHostImplTest {
+ protected:
+  scoped_ptr<OutputSurface> CreateOutputSurface() override {
+    return FakeOutputSurface::Create3dWithResourcelessSoftwareSupport();
   }
+};
+
+TEST_F(ResourcelessSoftwareLayerTreeHostImplTest,
+       ResourcelessSoftwareSetNeedsRedraw) {
+  SetupRootLayerImpl(LayerImpl::Create(host_impl_->active_tree(), 1));
+
+  const gfx::Size viewport_size(100, 100);
+  host_impl_->SetViewportSize(viewport_size);
+
+  const gfx::Transform draw_transform;
+  const gfx::Rect draw_viewport(viewport_size);
+  const gfx::Rect clip(viewport_size);
+  bool resourceless_software_draw = false;
+
+  // Clear any damage.
+  host_impl_->OnDraw(draw_transform, draw_viewport, clip,
+                     resourceless_software_draw);
+  last_on_draw_frame_.reset();
+
+  // Always swap even if same draw params.
+  resourceless_software_draw = true;
+  host_impl_->OnDraw(draw_transform, draw_viewport, clip,
+                     resourceless_software_draw);
+  EXPECT_FALSE(last_on_draw_frame_->has_no_damage);
+  last_on_draw_frame_.reset();
+
+  // Next hardware draw has damage.
+  resourceless_software_draw = false;
+  host_impl_->OnDraw(draw_transform, draw_viewport, clip,
+                     resourceless_software_draw);
+  EXPECT_FALSE(last_on_draw_frame_->has_no_damage);
 }
 
 TEST_F(LayerTreeHostImplTest, ExternalViewportAffectsVisibleRects) {
@@ -8542,21 +8558,19 @@ TEST_F(LayerTreeHostImplTest, ExternalViewportAffectsVisibleRects) {
   gfx::Rect external_viewport(10, 20);
   gfx::Rect external_clip(layer_size);
   bool resourceless_software_draw = false;
-  host_impl_->SetExternalDrawConstraints(
-      external_transform, external_viewport, external_clip, external_viewport,
-      external_transform, resourceless_software_draw);
-
-  // Visible rects should now be clipped by the external viewport.
-  host_impl_->active_tree()->UpdateDrawProperties(update_lcd_text);
+  host_impl_->SetExternalTilePriorityConstraints(external_viewport,
+                                                 external_transform);
+  host_impl_->OnDraw(external_transform, external_viewport, external_clip,
+                     resourceless_software_draw);
   EXPECT_EQ(gfx::Rect(10, 20), content_layer->visible_layer_rect());
 
   // Clear the external viewport.
   external_viewport = gfx::Rect();
-  host_impl_->SetExternalDrawConstraints(
-      external_transform, external_viewport, external_clip, external_viewport,
-      external_transform, resourceless_software_draw);
+  host_impl_->SetExternalTilePriorityConstraints(external_viewport,
+                                                 external_transform);
 
-  host_impl_->active_tree()->UpdateDrawProperties(update_lcd_text);
+  host_impl_->OnDraw(external_transform, external_viewport, external_clip,
+                     resourceless_software_draw);
   EXPECT_EQ(gfx::Rect(90, 90), content_layer->visible_layer_rect());
 }
 
@@ -8581,22 +8595,22 @@ TEST_F(LayerTreeHostImplTest, ExternalTransformAffectsVisibleRects) {
   gfx::Rect external_viewport;
   gfx::Rect external_clip(layer_size);
   bool resourceless_software_draw = false;
-  host_impl_->SetExternalDrawConstraints(
-      external_transform, external_viewport, external_clip, external_viewport,
-      external_transform, resourceless_software_draw);
+  host_impl_->SetExternalTilePriorityConstraints(external_viewport,
+                                                 external_transform);
 
   // Visible rects should now be shifted and scaled because of the external
   // transform.
-  host_impl_->active_tree()->UpdateDrawProperties(update_lcd_text);
+  host_impl_->OnDraw(external_transform, external_viewport, external_clip,
+                     resourceless_software_draw);
   EXPECT_EQ(gfx::Rect(20, 20), content_layer->visible_layer_rect());
 
   // Clear the external transform.
   external_transform = gfx::Transform();
-  host_impl_->SetExternalDrawConstraints(
-      external_transform, external_viewport, external_clip, external_viewport,
-      external_transform, resourceless_software_draw);
+  host_impl_->SetExternalTilePriorityConstraints(external_viewport,
+                                                 external_transform);
 
-  host_impl_->active_tree()->UpdateDrawProperties(update_lcd_text);
+  host_impl_->OnDraw(external_transform, external_viewport, external_clip,
+                     resourceless_software_draw);
   EXPECT_EQ(gfx::Rect(50, 50), content_layer->visible_layer_rect());
 }
 
@@ -8632,23 +8646,23 @@ TEST_F(LayerTreeHostImplTest, ExternalTransformAffectsSublayerScaleFactor) {
   gfx::Rect external_viewport;
   gfx::Rect external_clip(layer_size);
   bool resourceless_software_draw = false;
-  host_impl_->SetExternalDrawConstraints(
-      external_transform, external_viewport, external_clip, external_viewport,
-      external_transform, resourceless_software_draw);
+  host_impl_->SetExternalTilePriorityConstraints(external_viewport,
+                                                 external_transform);
 
   // Transform node's sublayer scale should include the device transform scale.
-  host_impl_->active_tree()->UpdateDrawProperties(update_lcd_text);
+  host_impl_->OnDraw(external_transform, external_viewport, external_clip,
+                     resourceless_software_draw);
   node = host_impl_->active_tree()->property_trees()->transform_tree.Node(
       test_layer->transform_tree_index());
   EXPECT_EQ(node->data.sublayer_scale, gfx::Vector2dF(2.f, 2.f));
 
   // Clear the external transform.
   external_transform = gfx::Transform();
-  host_impl_->SetExternalDrawConstraints(
-      external_transform, external_viewport, external_clip, external_viewport,
-      external_transform, resourceless_software_draw);
+  host_impl_->SetExternalTilePriorityConstraints(external_viewport,
+                                                 external_transform);
 
-  host_impl_->active_tree()->UpdateDrawProperties(update_lcd_text);
+  host_impl_->OnDraw(external_transform, external_viewport, external_clip,
+                     resourceless_software_draw);
   node = host_impl_->active_tree()->property_trees()->transform_tree.Node(
       test_layer->transform_tree_index());
   EXPECT_EQ(node->data.sublayer_scale, gfx::Vector2dF(1.f, 1.f));