CC: Fix missing swap-used-incomplete-tile updates

cc/trees/layer_tree_host_unittest_damage.cc

 // Copyright 2012 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 "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 670 matching lines @@
 
   virtual void AfterTest() OVERRIDE {
     EXPECT_EQ(3, did_swaps_);
   }
 
   int did_swaps_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostDamageTestScrollbarCommitDoesNoDamage);
 
+class LayerTreeHostDamageTestVisibleTilesStillTriggerDraws
+    : public LayerTreeHostDamageTest {
+
+  virtual void BeginTest() OVERRIDE {
+    if (!settings_.impl_side_painting) {

[brianderson, 2013/09/07 00:50:37]

Is there a macro that does not instantiate the MainThread version of this test?

[epenner, 2013/09/07 00:57:15]

Doesn't look like it, and the code to do it is rather ugly. But I can add a
macro or copy that code in here if desired.

[danakj, 2013/09/07 00:59:05]

Just override InitializeSettings and turn impl painting on for this test always.

[epenner, 2013/09/07 01:52:23]

That seemed less intuitive if it fails. But not very much so sounds good.

Done.

+      EndTest();
+      return;
+    }
+    PostSetNeedsCommitToMainThread();
+  }
+
+  virtual void SetupTree() OVERRIDE {
+    root_ = FakeContentLayer::Create(&client_);
+    root_->SetBounds(gfx::Size(500, 500));
+    layer_tree_host()->SetRootLayer(root_);
+    LayerTreeHostDamageTest::SetupTree();
+
+    swap_count_ = 0;
+    prepare_to_draw_count_ = 0;
+    update_visible_tile_count_ = 0;
+  }
+
+  virtual bool PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
+                                     LayerTreeHostImpl::FrameData* frame_data,
+                                     bool result) OVERRIDE {
+    EXPECT_TRUE(result);
+    prepare_to_draw_count_++;
+    switch (prepare_to_draw_count_) {
+      case 1:
+        // Detect that we have an incomplete tile, during the first frame.
+        // The first frame should have damage.
+        frame_data->contains_incomplete_tile = true;
+        DCHECK(!frame_data->has_no_damage);
+        break;
+      case 2:
+        // Make a no-damage frame. We early out and can't detect
+        // incomplete tiles, even if they still exist.
+        frame_data->contains_incomplete_tile = false;
+        frame_data->has_no_damage = true;
+        break;
+      case 3:
+        // Trigger the last swap for the completed tile.
+        frame_data->contains_incomplete_tile = false;
+        frame_data->has_no_damage = false;
+        EndTest();
+      case 4:
+      case 5:
+      case 6:
+        break;

[brianderson, 2013/09/07 00:50:37]

Are cases 4-6 needed?

[epenner, 2013/09/07 00:57:15]

Oops. Removed those. Done.

+      default:
+        NOTREACHED();
+        break;
+    }
+
+    return result;
+  }
+
+  virtual void UpdateVisibleTilesOnThread(
+      LayerTreeHostImpl* host_impl) OVERRIDE {
+    // Simulate creating some visible tiles (that trigger prepare-to-draws).
+    // The first we make into a no-damage-frame during prepare-to-draw (see
+    // above). This is to insure we still get UpdateVisibleTiles calls after

[brianderson, 2013/09/07 00:50:37]

nit: ensure

[epenner, 2013/09/07 00:57:15]

Done.

+    // a no-damage or aborted frame.
+    update_visible_tile_count_++;
+    switch (update_visible_tile_count_) {
+      case 3:
+      case 6:
+        host_impl->DidInitializeVisibleTile();
+        break;
+      case 7:
+        NOTREACHED();
+        break;
+    }
+  }
+
+  virtual void SwapBuffersOnThread(LayerTreeHostImpl* host_impl,
+                                   bool didSwap) OVERRIDE {
+    if (!didSwap)
+      return;
+    ++swap_count_;
+  }
+
+  virtual void AfterTest() OVERRIDE {
+    if (!settings_.impl_side_painting)
+      return;
+    EXPECT_EQ(update_visible_tile_count_, 6);
+    EXPECT_EQ(prepare_to_draw_count_, 3);
+    EXPECT_EQ(swap_count_, 2);
+  }
+
+  FakeContentLayerClient client_;
+  scoped_refptr<FakeContentLayer> root_;
+  int swap_count_;
+  int prepare_to_draw_count_;
+  int update_visible_tile_count_;
+};
+
+MULTI_THREAD_TEST_F(LayerTreeHostDamageTestVisibleTilesStillTriggerDraws);
+
 }  // namespace
 }  // namespace cc