cc: Prepare removing draw_and_swap_full_viewport_every_frame

Some sync compositor (ie android webview) code paths assume every OnDraw
will swap. Remove these assumptions in preparation for patially removing
draw_and_swap_full_viewport_every_frame behavior.

BUG=419795
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1413433002

Cr-Commit-Position: refs/heads/master@{#354683}

4 files changed, 100 insertions, 10 deletions

diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 2449788..55c37af 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -1416,10 +1416,18 @@ void LayerTreeHostImpl::SetExternalDrawConstraints(
     }
   }
 
-  if (external_transform_ != transform || external_viewport_ != viewport ||
-      resourceless_software_draw_ != resourceless_software_draw ||
+  const bool transform_changed = external_transform_ != transform;
+  const bool viewport_changed = external_viewport_ != viewport;
+  const bool clip_changed = external_clip_ != clip;
+  const bool resourceless_software_draw_changed =
+      resourceless_software_draw_ != resourceless_software_draw;
+  const bool tile_priority_params_changed =
       viewport_rect_for_tile_priority_ !=
-          viewport_rect_for_tile_priority_in_view_space) {
+      viewport_rect_for_tile_priority_in_view_space;
+
+  // UpdateDrawProperties does not depend on clip.
+  if (transform_changed || viewport_changed ||
+      resourceless_software_draw_changed || tile_priority_params_changed) {
     active_tree_->set_needs_update_draw_properties();
   }
 
@@ -1429,6 +1437,16 @@ void LayerTreeHostImpl::SetExternalDrawConstraints(
   viewport_rect_for_tile_priority_ =
       viewport_rect_for_tile_priority_in_view_space;
   resourceless_software_draw_ = resourceless_software_draw;
+
+  // When not toggling resourceless software draw, need to set redraw for
+  // all changes to draw parameters. Damage will be set externally by Android
+  // WebView for resourceless software draw toggles, so ignored here.
+  const bool draw_params_changed = transform_changed || viewport_changed ||
+                                   clip_changed || tile_priority_params_changed;
+  if (!resourceless_software_draw_changed && draw_params_changed) {
+    SetFullRootLayerDamage();
+    SetNeedsRedraw();
+  }
 }
 
 void LayerTreeHostImpl::SetNeedsRedrawRect(const gfx::Rect& damage_rect) {
@@ -2797,13 +2815,16 @@ void LayerTreeHostImpl::RequestUpdateForSynchronousInputHandler() {
 
 void LayerTreeHostImpl::SetSynchronousInputHandlerRootScrollOffset(
     const gfx::ScrollOffset& root_offset) {
-  active_tree_->DistributeRootScrollOffset(root_offset);
+  bool changed = active_tree_->DistributeRootScrollOffset(root_offset);
+  if (!changed)
+    return;
+
   client_->SetNeedsCommitOnImplThread();
   // After applying the synchronous input handler's scroll offset, tell it what
   // we ended up with.
   UpdateRootLayerStateForSynchronousInputHandler();
-  // No need to SetNeedsRedraw, this is for WebView and every frame has redraw
-  // requested by the WebView embedder already.
+  SetFullRootLayerDamage();
+  SetNeedsRedraw();
 }
 
 void LayerTreeHostImpl::ClearCurrentlyScrollingLayer() {
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index 6f69b5f..9232c5a 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -8177,6 +8177,74 @@ TEST_F(LayerTreeHostImplTest, ExternalTransformReflectedInNextDraw) {
       external_transform, layer->draw_properties().target_space_transform);
 }
 
+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);
+  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);
+  }
+
+  // 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);
+  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);
+  }
+
+  // Resourceless software draw toggles do not need redraw. Damage is
+  // set externally by SynchronousCompositorOutputSurface in this case.
+
+  // Setting resourceless_software_draw do not need redraw.
+  did_request_redraw_ = false;
+  resourceless_software_draw = true;
+  host_impl_->SetExternalDrawConstraints(
+      external_transform, external_viewport, external_clip1, 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);
+  }
+
+  // Unsetting resourceless_software_draw do not need redraw.
+  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);
+  }
+}
+
 TEST_F(LayerTreeHostImplTest, ScrollAnimated) {
   SetupScrollAndContentsLayers(gfx::Size(100, 200));
   DrawFrame();
diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc
index a77e517..35b6818 100644
--- a/cc/trees/layer_tree_impl.cc
+++ b/cc/trees/layer_tree_impl.cc
@@ -1075,10 +1075,10 @@ void LayerTreeImpl::AsValueInto(base::trace_event::TracedValue* state) const {
   state->EndArray();
 }
 
-void LayerTreeImpl::DistributeRootScrollOffset(
+bool LayerTreeImpl::DistributeRootScrollOffset(
     const gfx::ScrollOffset& root_offset) {
   if (!InnerViewportScrollLayer())
-    return;
+    return false;
 
   DCHECK(OuterViewportScrollLayer());
 
@@ -1092,7 +1092,7 @@ void LayerTreeImpl::DistributeRootScrollOffset(
   // It may be nothing has changed.
   DCHECK(inner_viewport_offset + outer_viewport_offset == TotalScrollOffset());
   if (inner_viewport_offset + outer_viewport_offset == root_offset)
-    return;
+    return false;
 
   gfx::ScrollOffset max_outer_viewport_scroll_offset =
       OuterViewportScrollLayer()->MaxScrollOffset();
@@ -1104,6 +1104,7 @@ void LayerTreeImpl::DistributeRootScrollOffset(
   OuterViewportScrollLayer()->SetCurrentScrollOffset(outer_viewport_offset);
   inner_viewport_offset = root_offset - outer_viewport_offset;
   InnerViewportScrollLayer()->SetCurrentScrollOffset(inner_viewport_offset);
+  return true;
 }
 
 void LayerTreeImpl::QueueSwapPromise(scoped_ptr<SwapPromise> swap_promise) {
diff --git a/cc/trees/layer_tree_impl.h b/cc/trees/layer_tree_impl.h
index 10a2748..6d54438 100644
--- a/cc/trees/layer_tree_impl.h
+++ b/cc/trees/layer_tree_impl.h
@@ -271,7 +271,7 @@ class CC_EXPORT LayerTreeImpl {
 
   // Distribute the root scroll between outer and inner viewport scroll layer.
   // The outer viewport scroll layer scrolls first.
-  void DistributeRootScrollOffset(const gfx::ScrollOffset& root_offset);
+  bool DistributeRootScrollOffset(const gfx::ScrollOffset& root_offset);
 
   void ApplyScroll(LayerImpl* layer, ScrollState* scroll_state) {
     layer_tree_host_impl_->ApplyScroll(layer, scroll_state);