Update from chromium 62675d9fb31fb8cedc40f68e78e8445a74f362e7

cc/resources/tile_manager_unittest.cc

 // Copyright 2013 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/resources/eviction_tile_priority_queue.h"
 #include "cc/resources/raster_tile_priority_queue.h"
 #include "cc/resources/tile.h"
 #include "cc/resources/tile_priority.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
@@ skipping 304 matching lines @@
     queue.Pop();
   }
 
   EXPECT_EQ(tile_count, new_content_tiles.size());
   EXPECT_EQ(high_res_tiles, new_content_tiles);
   // Since we don't guarantee increasing distance due to spiral iterator, we
   // should check that we're _mostly_ right.
   EXPECT_GE(increasing_distance_tiles, 3 * tile_count / 4);
 }
 
+TEST_F(TileManagerTilePriorityQueueTest, ActivationComesBeforeEventually) {
+  SetupDefaultTrees(gfx::Size(1000, 1000));
+
+  active_layer_->CreateDefaultTilingsAndTiles();
+  pending_layer_->CreateDefaultTilingsAndTiles();
+
+  // Create a pending child layer.
+  gfx::Size tile_size(256, 256);
+  scoped_refptr<FakePicturePileImpl> pending_pile =
+      FakePicturePileImpl::CreateFilledPile(tile_size, gfx::Size(1000, 1000));
+  scoped_ptr<FakePictureLayerImpl> pending_child =
+      FakePictureLayerImpl::CreateWithPile(
+          host_impl_.pending_tree(), id_ + 1, pending_pile);
+  pending_layer_->AddChild(pending_child.Pass());
+  FakePictureLayerImpl* pending_child_raw = static_cast<FakePictureLayerImpl*>(
+      host_impl_.pending_tree()->LayerById(id_ + 1));
+  ASSERT_TRUE(pending_child_raw);
+
+  pending_child_raw->SetDrawsContent(true);
+  pending_child_raw->DoPostCommitInitializationIfNeeded();
+  pending_child_raw->CreateDefaultTilingsAndTiles();
+  ASSERT_TRUE(pending_child_raw->HighResTiling());
+
+  // Set a small viewport, so we have soon and eventually tiles.
+  gfx::Rect viewport(200, 200);
+  active_layer_->draw_properties().visible_content_rect = viewport;
+  active_layer_->UpdateTiles(Occlusion(), false);
+  pending_layer_->draw_properties().visible_content_rect = viewport;
+  pending_layer_->UpdateTiles(Occlusion(), false);
+  pending_child_raw->draw_properties().visible_content_rect = viewport;
+  pending_child_raw->UpdateTiles(Occlusion(), false);
+
+  RasterTilePriorityQueue queue;
+  host_impl_.SetRequiresHighResToDraw();
+  host_impl_.BuildRasterQueue(&queue, SMOOTHNESS_TAKES_PRIORITY);
+  EXPECT_FALSE(queue.IsEmpty());
+
+  // Get all the tiles that are NOW or SOON and make sure they are ready to
+  // draw.
+  std::vector<Tile*> all_tiles;
+  while (!queue.IsEmpty()) {
+    Tile* tile = queue.Top();
+    if (tile->combined_priority().priority_bin >= TilePriority::EVENTUALLY)
+      break;
+
+    all_tiles.push_back(tile);
+    queue.Pop();
+  }
+
+  tile_manager()->InitializeTilesWithResourcesForTesting(
+      std::vector<Tile*>(all_tiles.begin(), all_tiles.end()));
+
+  // Ensure we can activate.
+  EXPECT_TRUE(pending_layer_->AllTilesRequiredForActivationAreReadyToDraw());
+  EXPECT_TRUE(pending_child_raw->AllTilesRequiredForActivationAreReadyToDraw());
+}
+
 TEST_F(TileManagerTilePriorityQueueTest, EvictionTilePriorityQueue) {
   SetupDefaultTrees(gfx::Size(1000, 1000));
 
   active_layer_->CreateDefaultTilingsAndTiles();
   pending_layer_->CreateDefaultTilingsAndTiles();
 
   EvictionTilePriorityQueue empty_queue;
   host_impl_.BuildEvictionQueue(&empty_queue, SAME_PRIORITY_FOR_BOTH_TREES);
   EXPECT_TRUE(empty_queue.IsEmpty());
   std::set<Tile*> all_tiles;
@@ skipping 357 matching lines @@
     all_tiles.insert(queue.Top());
     ++tile_count;
     queue.Pop();
   }
   EXPECT_EQ(tile_count, all_tiles.size());
   EXPECT_EQ(16u, tile_count);
 }
 
 }  // namespace
 }  // namespace cc