SetNeedsRedraw directly when updating a visible tile.

cc/resources/tile_manager.h

 // 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.
 
 #ifndef CC_RESOURCES_TILE_MANAGER_H_
 #define CC_RESOURCES_TILE_MANAGER_H_
 
 #include <deque>
 #include <queue>
 #include <set>
@@ skipping 86 matching lines @@
       TileManagerClient* client,
       base::SequencedTaskRunner* task_runner,
       ResourcePool* resource_pool,
       Rasterizer* rasterizer,
       RenderingStatsInstrumentation* rendering_stats_instrumentation,
       size_t scheduled_raster_task_limit);
   ~TileManager() override;
 
   void ManageTiles(const GlobalStateThatImpactsTilePriority& state);
 
-  // Returns true when visible tiles have been initialized.
-  bool UpdateVisibleTiles();
+  void UpdateVisibleTiles();
+
+  bool has_active_visible_tile_scheduled() {

[reveman, 2014/10/30 19:37:42]

I think this is too implementation specific. For example, it will return very
different results depending on the value of scheduled_raster_task_limit_. I'm
also worried that exposing implementation specific details such as this will
create friction when trying to make changes to the tile manager.

Something like IsTopPriorityUninitializedTileVisibleAndOnActiveTree() would be
better as it's well defined. Not sure you need to reach into the tile manager to
answer that though.

[danakj, 2014/10/30 19:49:07]

And I think that all of those results would be acceptable for our uses.
We just need a signal that there's some work being that would be visible. I
didn't write any tests that tie this into being very specific. The test I added
is causing some tiles at a new scale to be created and trying to draw until they
are done. That's the use case we care about, and as long as we satisfy that, we
can change the signal that the tile manager gives out as much as we like.
I think it has to come from the tile manager, cuz it needs to know what tiles
the raster iterators are going to spit out, which is generated from the tile
manager.

I agree IsTopPriorityUninitializedTileVisibleAndOnActiveTree would probably be
enough. It should be for the test case I've written, so I'll try that out.
Thanks!

+    return has_active_visible_tile_scheduled_;
+  }
 
   scoped_refptr<Tile> CreateTile(RasterSource* raster_source,
                                  const gfx::Size& tile_size,
                                  const gfx::Rect& content_rect,
                                  float contents_scale,
                                  int layer_id,
                                  int source_frame_number,
                                  int flags);
 
   scoped_refptr<base::debug::ConvertableToTraceFormat> BasicStateAsValue()
@@ skipping 122 matching lines @@
   const size_t scheduled_raster_task_limit_;
 
   typedef base::hash_map<Tile::Id, Tile*> TileMap;
   TileMap tiles_;
 
   bool all_tiles_that_need_to_be_rasterized_are_scheduled_;
   MemoryHistory::Entry memory_stats_from_last_assign_;
 
   RenderingStatsInstrumentation* rendering_stats_instrumentation_;
 
-  bool did_initialize_visible_tile_;
   bool did_check_for_completed_tasks_since_last_schedule_tasks_;
   bool did_oom_on_last_assign_;
+  bool has_active_visible_tile_scheduled_;
 
   typedef base::hash_map<uint32_t, scoped_refptr<ImageDecodeTask>>
       PixelRefTaskMap;
   typedef base::hash_map<int, PixelRefTaskMap> LayerPixelRefTaskMap;
   LayerPixelRefTaskMap image_decode_tasks_;
 
   typedef base::hash_map<int, int> LayerCountMap;
   LayerCountMap used_layer_counts_;
 
   RasterTaskCompletionStats update_visible_tiles_stats_;
@@ skipping 12 matching lines @@
   RasterTilePriorityQueue raster_priority_queue_;
   EvictionTilePriorityQueue eviction_priority_queue_;
   bool eviction_priority_queue_is_up_to_date_;
 
   DISALLOW_COPY_AND_ASSIGN(TileManager);
 };
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_TILE_MANAGER_H_