SetNeedsRedraw directly when updating a visible tile.

cc/resources/tile_manager.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/resources/tile_manager.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
@@ skipping 307 matching lines @@
 
     bool memory_usage_above_limit = resource_pool_->total_memory_usage_bytes() >
                                     global_state_.soft_memory_limit_in_bytes;
 
     // When OOM, keep re-assigning memory until we reach a steady state
     // where top-priority tiles are initialized.
     if (all_tiles_that_need_to_be_rasterized_are_scheduled_ &&
         !memory_usage_above_limit)
       return;
 
     rasterizer_->CheckForCompletedTasks();

[vmpstr, 2014/10/28 01:35:34]

This would normally check completed tasks, but not if we scheduled everything
successfully last time (early out above; so like a page with < 32 tiles total)

[danakj, 2014/10/31 20:02:01]

Right, I ended up not moving this anymore. Now instead I used manfred's
NotifyReadyToDraw() call to LTHI to tell it when all tiles are done, and his
CheckIfReadyToDraw() does this CheckForCompletedTasks().

Further, once we go to draw as a result of the NotifyReadyToDraw(), we'll
UpdateVisibleTiles there, so this should work out?

     did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
     TileVector tiles_that_need_to_be_rasterized;
     AssignGpuMemoryToTiles(&tiles_that_need_to_be_rasterized);
 
     // |tiles_that_need_to_be_rasterized| will be empty when we reach a
     // steady memory state. Keep scheduling tasks until we reach this state.
     if (!tiles_that_need_to_be_rasterized.empty()) {
       ScheduleTasks(tiles_that_need_to_be_rasterized);
       return;
@@ skipping 26 matching lines @@
       ManagedTileState& mts = tile->managed_state();
 
       if (tile->required_for_activation() && !mts.draw_info.IsReadyToDraw()) {
         // If we can't raster on demand, give up early (and don't activate).
         if (!allow_rasterize_on_demand) {
           ready_to_activate = false;
           break;
         }
 
         mts.draw_info.set_rasterize_on_demand();
-        client_->NotifyTileStateChanged(tile);
+        bool visible_tile =
+            tile->priority(ACTIVE_TREE).distance_to_visible == 0.f;
+        client_->NotifyTileStateChanged(tile, visible_tile);
       }
       raster_priority_queue_.Pop();
     }
 
     if (ready_to_activate) {
       DCHECK(IsReadyToActivate());
       ready_to_activate_check_notifier_.Schedule();
     }
     raster_priority_queue_.Reset();
     return;
@@ skipping 36 matching lines @@
                        BasicStateAsValue());
 
   TRACE_COUNTER_ID1("cc",
                     "unused_memory_bytes",
                     this,
                     resource_pool_->total_memory_usage_bytes() -
                         resource_pool_->acquired_memory_usage_bytes());
 }
 
 bool TileManager::UpdateVisibleTiles() {
+  return false;
   TRACE_EVENT0("cc", "TileManager::UpdateVisibleTiles");
 
   rasterizer_->CheckForCompletedTasks();

[vmpstr, 2014/10/28 01:35:34]

We still need something to check for completed tasks before drawing, otherwise
we won't actually issue completion callbacks (and not initialize tiles). Maybe?

[enne (OOO), 2014/10/28 18:09:21]

Yeah.  If we're using async uploads, we need to check for completed tasks or no
tile will be ready even if it is.

[danakj, 2014/10/31 20:02:01]

Right, no longer changing this method.

   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   TRACE_EVENT_INSTANT1(
       "cc",
       "DidUpdateVisibleTiles",
       TRACE_EVENT_SCOPE_THREAD,
       "stats",
       RasterTaskCompletionStatsAsValue(update_visible_tiles_stats_));
   update_visible_tiles_stats_ = RasterTaskCompletionStats();
 
@@ skipping 204 matching lines @@
 void TileManager::FreeResourcesForTile(Tile* tile) {
   ManagedTileState& mts = tile->managed_state();
   if (mts.draw_info.resource_)
     resource_pool_->ReleaseResource(mts.draw_info.resource_.Pass());
 }
 
 void TileManager::FreeResourcesForTileAndNotifyClientIfTileWasReadyToDraw(
     Tile* tile) {
   bool was_ready_to_draw = tile->IsReadyToDraw();
   FreeResourcesForTile(tile);
-  if (was_ready_to_draw)
-    client_->NotifyTileStateChanged(tile);
+  if (was_ready_to_draw) {
+    bool visible_tile = tile->priority(ACTIVE_TREE).distance_to_visible == 0.f;
+    client_->NotifyTileStateChanged(tile, visible_tile);
+  }
 }
 
 void TileManager::ScheduleTasks(
     const TileVector& tiles_that_need_to_be_rasterized) {
   TRACE_EVENT1("cc",
                "TileManager::ScheduleTasks",
                "count",
                tiles_that_need_to_be_rasterized.size());
 
   DCHECK(did_check_for_completed_tasks_since_last_schedule_tasks_);
@@ skipping 143 matching lines @@
   ++update_visible_tiles_stats_.completed_count;
 
   if (analysis.is_solid_color) {
     mts.draw_info.set_solid_color(analysis.solid_color);
     resource_pool_->ReleaseResource(resource.Pass());
   } else {
     mts.draw_info.set_use_resource();
     mts.draw_info.resource_ = resource.Pass();
   }
 
-  if (tile->priority(ACTIVE_TREE).distance_to_visible == 0.f)
+  bool visible_tile = false;
+  if (tile->priority(ACTIVE_TREE).distance_to_visible == 0.f) {
+    visible_tile = true;
     did_initialize_visible_tile_ = true;
+  }
 
-  client_->NotifyTileStateChanged(tile);
+  client_->NotifyTileStateChanged(tile, visible_tile);
 }
 
 scoped_refptr<Tile> TileManager::CreateTile(PicturePileImpl* picture_pile,
                                             const gfx::Size& tile_size,
                                             const gfx::Rect& content_rect,
                                             float contents_scale,
                                             int layer_id,
                                             int source_frame_number,
                                             int flags) {
   scoped_refptr<Tile> tile = make_scoped_refptr(new Tile(this,
@@ skipping 83 matching lines @@
   result -= other;
   return result;
 }
 
 bool TileManager::MemoryUsage::Exceeds(const MemoryUsage& limit) const {
   return memory_bytes_ > limit.memory_bytes_ ||
          resource_count_ > limit.resource_count_;
 }
 
 }  // namespace cc