cc: Avoid redraw for missing tile outside visible rect

cc/trees/layer_tree_host_impl_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_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 1861 matching lines @@
   EXPECT_TRUE(root->did_draw_called());
   EXPECT_TRUE(layer1->did_draw_called());
   EXPECT_TRUE(layer2->did_draw_called());
 
   EXPECT_NE(root->render_surface(), layer1->render_surface());
   EXPECT_TRUE(!!layer1->render_surface());
 }
 
 class MissingTextureAnimatingLayer : public DidDrawCheckLayer {
  public:
-  static scoped_ptr<LayerImpl> Create(LayerTreeImpl* tree_impl,
-                                      int id,
-                                      bool tile_missing,
-                                      bool had_incomplete_tile,
-                                      bool animating,
-                                      ResourceProvider* resource_provider) {
-    return scoped_ptr<LayerImpl>(
-        new MissingTextureAnimatingLayer(tree_impl,
-                                         id,
-                                         tile_missing,
-                                         had_incomplete_tile,
-                                         animating,
-                                         resource_provider));
+  static scoped_ptr<LayerImpl> Create(
+      LayerTreeImpl* tree_impl,
+      int id,
+      bool tile_missing,
+      bool tile_missing_outside_activation_rect,
+      bool had_incomplete_tile,
+      bool had_incomplete_tile_outside_activation_rect,
+      bool animating,
+      ResourceProvider* resource_provider) {
+    return scoped_ptr<LayerImpl>(new MissingTextureAnimatingLayer(
+        tree_impl,
+        id,
+        tile_missing,
+        tile_missing_outside_activation_rect,
+        had_incomplete_tile,
+        had_incomplete_tile_outside_activation_rect,
+        animating,
+        resource_provider));
   }
 
   virtual void AppendQuads(RenderPass* render_pass,
                            const OcclusionTracker<LayerImpl>& occlusion_tracker,
                            AppendQuadsData* append_quads_data) OVERRIDE {
     LayerImpl::AppendQuads(render_pass, occlusion_tracker, append_quads_data);
-    if (had_incomplete_tile_)
+    if (had_incomplete_tile_) {
       append_quads_data->num_incomplete_tiles++;
-    if (tile_missing_)
+      append_quads_data->num_incomplete_tiles_inside_activation_rect++;
+    }
+    if (had_incomplete_tile_outside_activation_rect_) {
+      append_quads_data->num_incomplete_tiles++;
+    }
+    if (tile_missing_) {
       append_quads_data->num_missing_tiles++;
+      append_quads_data->num_missing_tiles_inside_activation_rect++;
+    }
+    if (tile_missing_outside_activation_rect_) {
+      append_quads_data->num_missing_tiles++;
+    }
   }
 
  private:
   MissingTextureAnimatingLayer(LayerTreeImpl* tree_impl,
                                int id,
                                bool tile_missing,
+                               bool tile_missing_outside_activation_rect,
                                bool had_incomplete_tile,
+                               bool had_incomplete_tile_outside_activation_rect,
                                bool animating,
                                ResourceProvider* resource_provider)
       : DidDrawCheckLayer(tree_impl, id),
         tile_missing_(tile_missing),
-        had_incomplete_tile_(had_incomplete_tile) {
+        tile_missing_outside_activation_rect_(
+            tile_missing_outside_activation_rect),
+        had_incomplete_tile_(had_incomplete_tile),
+        had_incomplete_tile_outside_activation_rect_(
+            had_incomplete_tile_outside_activation_rect) {
     if (animating)
       AddAnimatedTransformToLayer(this, 10.0, 3, 0);
   }
 
   bool tile_missing_;
+  bool tile_missing_outside_activation_rect_;
   bool had_incomplete_tile_;
+  bool had_incomplete_tile_outside_activation_rect_;
 };
 
 TEST_F(LayerTreeHostImplTest, PrepareToDrawSucceedsOnDefault) {
   host_impl_->active_tree()->SetRootLayer(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 1));
   DidDrawCheckLayer* root =
       static_cast<DidDrawCheckLayer*>(host_impl_->active_tree()->root_layer());
 
   bool tile_missing = false;
+  bool tile_missing_outside_activation_rect = false;
   bool had_incomplete_tile = false;
+  bool had_incomplete_tile_outside_activation_rect = false;
   bool is_animating = false;
-  root->AddChild(
-      MissingTextureAnimatingLayer::Create(host_impl_->active_tree(),
-                                           2,
-                                           tile_missing,
-                                           had_incomplete_tile,
-                                           is_animating,
-                                           host_impl_->resource_provider()));
+  root->AddChild(MissingTextureAnimatingLayer::Create(
+      host_impl_->active_tree(),
+      2,
+      tile_missing,
+      tile_missing_outside_activation_rect,
+      had_incomplete_tile,
+      had_incomplete_tile_outside_activation_rect,
+      is_animating,
+      host_impl_->resource_provider()));
 
   LayerTreeHostImpl::FrameData frame;
 
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(LayerTreeHostImplTest, PrepareToDrawSucceedsWithAnimatedLayer) {
   host_impl_->active_tree()->SetRootLayer(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 1));
   DidDrawCheckLayer* root =
       static_cast<DidDrawCheckLayer*>(host_impl_->active_tree()->root_layer());
   bool tile_missing = false;
+  bool tile_missing_outside_activation_rect = false;
   bool had_incomplete_tile = false;
+  bool had_incomplete_tile_outside_activation_rect = false;
   bool is_animating = true;
-  root->AddChild(
-      MissingTextureAnimatingLayer::Create(host_impl_->active_tree(),
-                                           2,
-                                           tile_missing,
-                                           had_incomplete_tile,
-                                           is_animating,
-                                           host_impl_->resource_provider()));
+  root->AddChild(MissingTextureAnimatingLayer::Create(
+      host_impl_->active_tree(),
+      2,
+      tile_missing,
+      tile_missing_outside_activation_rect,
+      had_incomplete_tile,
+      had_incomplete_tile_outside_activation_rect,
+      is_animating,
+      host_impl_->resource_provider()));
 
   LayerTreeHostImpl::FrameData frame;
 
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(LayerTreeHostImplTest, PrepareToDrawSucceedsWithMissingTiles) {
   host_impl_->active_tree()->SetRootLayer(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 3));
   DidDrawCheckLayer* root =
       static_cast<DidDrawCheckLayer*>(host_impl_->active_tree()->root_layer());
 
   bool tile_missing = true;
+  bool tile_missing_outside_activation_rect = false;
   bool had_incomplete_tile = false;
+  bool had_incomplete_tile_outside_activation_rect = false;
   bool is_animating = false;
-  root->AddChild(
-      MissingTextureAnimatingLayer::Create(host_impl_->active_tree(),
-                                           4,
-                                           tile_missing,
-                                           had_incomplete_tile,
-                                           is_animating,
-                                           host_impl_->resource_provider()));
+  root->AddChild(MissingTextureAnimatingLayer::Create(
+      host_impl_->active_tree(),
+      4,
+      tile_missing,
+      tile_missing_outside_activation_rect,
+      had_incomplete_tile,
+      had_incomplete_tile_outside_activation_rect,
+      is_animating,
+      host_impl_->resource_provider()));
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(LayerTreeHostImplTest, PrepareToDrawSucceedsWithIncompleteTile) {
   host_impl_->active_tree()->SetRootLayer(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 3));
   DidDrawCheckLayer* root =
       static_cast<DidDrawCheckLayer*>(host_impl_->active_tree()->root_layer());
 
   bool tile_missing = false;
+  bool tile_missing_outside_activation_rect = false;
   bool had_incomplete_tile = true;
+  bool had_incomplete_tile_outside_activation_rect = false;
   bool is_animating = false;
-  root->AddChild(
-      MissingTextureAnimatingLayer::Create(host_impl_->active_tree(),
-                                           4,
-                                           tile_missing,
-                                           had_incomplete_tile,
-                                           is_animating,
-                                           host_impl_->resource_provider()));
+  root->AddChild(MissingTextureAnimatingLayer::Create(
+      host_impl_->active_tree(),
+      4,
+      tile_missing,
+      tile_missing_outside_activation_rect,
+      had_incomplete_tile,
+      had_incomplete_tile_outside_activation_rect,
+      is_animating,
+      host_impl_->resource_provider()));
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
+  host_impl_->DidDrawAllLayers(frame);
+}
+
+TEST_F(LayerTreeHostImplTest,
+       PrepareToDrawSucceedsWithIncompleteTileOutsideActivationRect) {
+  host_impl_->active_tree()->SetRootLayer(
+      DidDrawCheckLayer::Create(host_impl_->active_tree(), 3));
+  DidDrawCheckLayer* root =
+      static_cast<DidDrawCheckLayer*>(host_impl_->active_tree()->root_layer());
+
+  bool tile_missing = false;
+  bool tile_missing_outside_activation_rect = false;
+  bool had_incomplete_tile = true;
+  bool had_incomplete_tile_outside_activation_rect = true;
+  bool is_animating = false;
+  root->AddChild(MissingTextureAnimatingLayer::Create(
+      host_impl_->active_tree(),
+      4,
+      tile_missing,
+      tile_missing_outside_activation_rect,
+      had_incomplete_tile,
+      had_incomplete_tile_outside_activation_rect,
+      is_animating,
+      host_impl_->resource_provider()));
+  LayerTreeHostImpl::FrameData frame;
+  EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
+  host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
+  host_impl_->DidDrawAllLayers(frame);
+}
+
+TEST_F(LayerTreeHostImplTest,
+       PrepareToDrawSucceedsWithMissingTileOutsideActivationRect) {
+  host_impl_->active_tree()->SetRootLayer(
+      DidDrawCheckLayer::Create(host_impl_->active_tree(), 3));
+  DidDrawCheckLayer* root =
+      static_cast<DidDrawCheckLayer*>(host_impl_->active_tree()->root_layer());
+
+  bool tile_missing = false;

[hush (inactive), 2014/08/18 20:48:16]

should this be true?
tile_missing_outside_activation_rect is true implies tile_missing is true,
right?

[boliu, 2014/08/18 21:32:57]

Not as written. But I can see why this is confusing.

Renamed the vars without suffix as "_inside_activation_rect".

+  bool tile_missing_outside_activation_rect = true;
+  bool had_incomplete_tile = true;
+  bool had_incomplete_tile_outside_activation_rect = false;

[hush (inactive), 2014/08/18 20:48:16]

above 2 lines means there are incomplete tiles inside the activation rect. How
about setting both to false, so that the existence of incomplete tiles does not
interfere with the test results? Because you are trying to test
PrepareToDrawSucceedsWithMissingTileOutsideActivationRect here.

[boliu, 2014/08/18 21:32:57]

Done. Good catch.

+  bool is_animating = false;
+  root->AddChild(MissingTextureAnimatingLayer::Create(
+      host_impl_->active_tree(),
+      4,
+      tile_missing,
+      tile_missing_outside_activation_rect,
+      had_incomplete_tile,
+      had_incomplete_tile_outside_activation_rect,
+      is_animating,
+      host_impl_->resource_provider()));
+  LayerTreeHostImpl::FrameData frame;
+  EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
+  host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(LayerTreeHostImplTest,
        PrepareToDrawFailsWithAnimationAndMissingTilesUsesCheckerboard) {
   host_impl_->active_tree()->SetRootLayer(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 5));
   DidDrawCheckLayer* root =
       static_cast<DidDrawCheckLayer*>(host_impl_->active_tree()->root_layer());
   bool tile_missing = true;
+  bool tile_missing_outside_activation_rect = false;
   bool had_incomplete_tile = false;
+  bool had_incomplete_tile_outside_activation_rect = false;
   bool is_animating = true;
-  root->AddChild(
-      MissingTextureAnimatingLayer::Create(host_impl_->active_tree(),
-                                           6,
-                                           tile_missing,
-                                           had_incomplete_tile,
-                                           is_animating,
-                                           host_impl_->resource_provider()));
+  root->AddChild(MissingTextureAnimatingLayer::Create(
+      host_impl_->active_tree(),
+      6,
+      tile_missing,
+      tile_missing_outside_activation_rect,
+      had_incomplete_tile,
+      had_incomplete_tile_outside_activation_rect,
+      is_animating,
+      host_impl_->resource_provider()));
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_ABORTED_CHECKERBOARD_ANIMATIONS,
             host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(LayerTreeHostImplTest,
        PrepareToDrawSucceedsWithAnimationAndIncompleteTiles) {
   host_impl_->active_tree()->SetRootLayer(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 5));
   DidDrawCheckLayer* root =
       static_cast<DidDrawCheckLayer*>(host_impl_->active_tree()->root_layer());
   bool tile_missing = false;
+  bool tile_missing_outside_activation_rect = false;
   bool had_incomplete_tile = true;
+  bool had_incomplete_tile_outside_activation_rect = false;
   bool is_animating = true;
-  root->AddChild(
-      MissingTextureAnimatingLayer::Create(host_impl_->active_tree(),
-                                           6,
-                                           tile_missing,
-                                           had_incomplete_tile,
-                                           is_animating,
-                                           host_impl_->resource_provider()));
+  root->AddChild(MissingTextureAnimatingLayer::Create(
+      host_impl_->active_tree(),
+      6,
+      tile_missing,
+      tile_missing_outside_activation_rect,
+      had_incomplete_tile,
+      had_incomplete_tile_outside_activation_rect,
+      is_animating,
+      host_impl_->resource_provider()));
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(LayerTreeHostImplTest, PrepareToDrawSucceedsWhenHighResRequired) {
   host_impl_->active_tree()->SetRootLayer(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 7));
   DidDrawCheckLayer* root =
       static_cast<DidDrawCheckLayer*>(host_impl_->active_tree()->root_layer());
   bool tile_missing = false;
+  bool tile_missing_outside_activation_rect = false;
   bool had_incomplete_tile = false;
+  bool had_incomplete_tile_outside_activation_rect = false;
   bool is_animating = false;
-  root->AddChild(
-      MissingTextureAnimatingLayer::Create(host_impl_->active_tree(),
-                                           8,
-                                           tile_missing,
-                                           had_incomplete_tile,
-                                           is_animating,
-                                           host_impl_->resource_provider()));
+  root->AddChild(MissingTextureAnimatingLayer::Create(
+      host_impl_->active_tree(),
+      8,
+      tile_missing,
+      tile_missing_outside_activation_rect,
+      had_incomplete_tile,
+      had_incomplete_tile_outside_activation_rect,
+      is_animating,
+      host_impl_->resource_provider()));
   host_impl_->active_tree()->SetRequiresHighResToDraw();
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(LayerTreeHostImplTest,
        PrepareToDrawFailsWhenHighResRequiredAndIncompleteTiles) {
   host_impl_->active_tree()->SetRootLayer(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 7));
   DidDrawCheckLayer* root =
       static_cast<DidDrawCheckLayer*>(host_impl_->active_tree()->root_layer());
   bool tile_missing = false;
+  bool tile_missing_outside_activation_rect = false;
   bool had_incomplete_tile = true;
+  bool had_incomplete_tile_outside_activation_rect = false;
   bool is_animating = false;
-  root->AddChild(
-      MissingTextureAnimatingLayer::Create(host_impl_->active_tree(),
-                                           8,
-                                           tile_missing,
-                                           had_incomplete_tile,
-                                           is_animating,
-                                           host_impl_->resource_provider()));
+  root->AddChild(MissingTextureAnimatingLayer::Create(
+      host_impl_->active_tree(),
+      8,
+      tile_missing,
+      tile_missing_outside_activation_rect,
+      had_incomplete_tile,
+      had_incomplete_tile_outside_activation_rect,
+      is_animating,
+      host_impl_->resource_provider()));
   host_impl_->active_tree()->SetRequiresHighResToDraw();
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_ABORTED_MISSING_HIGH_RES_CONTENT,
             host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(LayerTreeHostImplTest,
        PrepareToDrawFailsWhenHighResRequiredAndMissingTile) {
   host_impl_->active_tree()->SetRootLayer(
       DidDrawCheckLayer::Create(host_impl_->active_tree(), 7));
   DidDrawCheckLayer* root =
       static_cast<DidDrawCheckLayer*>(host_impl_->active_tree()->root_layer());
   bool tile_missing = true;
+  bool tile_missing_outside_activation_rect = false;
   bool had_incomplete_tile = false;
+  bool had_incomplete_tile_outside_activation_rect = false;
   bool is_animating = false;
-  root->AddChild(
-      MissingTextureAnimatingLayer::Create(host_impl_->active_tree(),
-                                           8,
-                                           tile_missing,
-                                           had_incomplete_tile,
-                                           is_animating,
-                                           host_impl_->resource_provider()));
+  root->AddChild(MissingTextureAnimatingLayer::Create(
+      host_impl_->active_tree(),
+      8,
+      tile_missing,
+      tile_missing_outside_activation_rect,
+      had_incomplete_tile,
+      had_incomplete_tile_outside_activation_rect,
+      is_animating,
+      host_impl_->resource_provider()));
   host_impl_->active_tree()->SetRequiresHighResToDraw();
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_ABORTED_MISSING_HIGH_RES_CONTENT,
             host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollRootIgnored) {
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
@@ skipping 4891 matching lines @@
   host_impl_->DidLoseOutputSurface();
   EXPECT_TRUE(host_impl_->IsContextLost());
   EXPECT_EQ(1, num_lost_surfaces_);
   host_impl_->DidLoseOutputSurface();
   EXPECT_TRUE(host_impl_->IsContextLost());
   EXPECT_EQ(1, num_lost_surfaces_);
 }
 
 }  // namespace
 }  // namespace cc