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 42 matching lines @@
   // - Tile resources freed.
   // - Tile marked for on-demand raster.
   virtual void NotifyTileStateChanged(const Tile* tile) = 0;
 
   // Given an empty raster tile priority queue, this will build a priority queue
   // that will return tiles in order in which they should be rasterized.
   // Note if the queue was previous built, Reset must be called on it.
   virtual void BuildRasterQueue(RasterTilePriorityQueue* queue,
                                 TreePriority tree_priority) = 0;
 
+  // Called when all tiles from the previous BuildRasterQueue have been

[vmpstr, 2014/10/31 15:46:30]

drive by nit: This isn't entirely true... It would be called when all tiles that
need to be processed under the currently memory policy have been processed. The
raster queue might still have tiles that are EVENTUALLY or something when we
have "prepaint only" policy. (to be clear, I think the code is correct it's just
the comment omits the fact that *handwave*memory policy*handwave*)

[danakj, 2014/10/31 15:47:30]

OK thanks I wasn't really sure what to write here, I tried :)

+  // processed. Each BuildRasterQueue call is followed by either another
+  // BuildRasterQueue call (when some tiles were processed but not all), or a
+  // FinishedRasterQueue() call.
+  virtual void FinishedRasterQueue() = 0;
+
   // Given an empty eviction tile priority queue, this will build a priority
   // queue that will return tiles in order in which they should be evicted.
   // Note if the queue was previous built, Reset must be called on it.
   virtual void BuildEvictionQueue(EvictionTilePriorityQueue* queue,
                                   TreePriority tree_priority) = 0;
 
  protected:
   virtual ~TileManagerClient() {}
 };
 
@@ skipping 24 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();
 
   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_;
 
   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_;
@@ skipping 14 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_