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 201 matching lines @@
     Rasterizer* rasterizer,
     RenderingStatsInstrumentation* rendering_stats_instrumentation,
     size_t scheduled_raster_task_limit)
     : client_(client),
       task_runner_(task_runner),
       resource_pool_(resource_pool),
       rasterizer_(rasterizer),
       scheduled_raster_task_limit_(scheduled_raster_task_limit),
       all_tiles_that_need_to_be_rasterized_are_scheduled_(true),
       rendering_stats_instrumentation_(rendering_stats_instrumentation),
-      did_initialize_visible_tile_(false),
       did_check_for_completed_tasks_since_last_schedule_tasks_(true),
       did_oom_on_last_assign_(false),
       ready_to_activate_check_notifier_(
           task_runner_.get(),
           base::Bind(&TileManager::CheckIfReadyToActivate,
                      base::Unretained(this))),
       ready_to_draw_check_notifier_(task_runner_.get(),
                                     base::Bind(&TileManager::CheckIfReadyToDraw,
                                                base::Unretained(this))) {
   rasterizer_->SetClient(this);
@@ skipping 131 matching lines @@
 
     if (ready_to_activate) {
       DCHECK(IsReadyToActivate());
       ready_to_activate_check_notifier_.Schedule();
     }
     raster_priority_queue_.Reset();
     return;
   }
 
   if (task_set == REQUIRED_FOR_DRAW) {
-    TRACE_EVENT1("cc",
-                 "TileManager::DidFinishRunningTasks",
-                 "task_set",
+    TRACE_EVENT1("cc", "TileManager::DidFinishRunningTasks", "task_set",
                  "REQUIRED_FOR_DRAW");
     ready_to_draw_check_notifier_.Schedule();
     return;
   }
 
   if (task_set == REQUIRED_FOR_ACTIVATION) {
     TRACE_EVENT1("cc",
                  "TileManager::DidFinishRunningTasks",
                  "task_set",
                  "REQUIRED_FOR_ACTIVATION");
@@ skipping 28 matching lines @@
                        "state",
                        BasicStateAsValue());
 
   TRACE_COUNTER_ID1("cc",
                     "unused_memory_bytes",
                     this,
                     resource_pool_->total_memory_usage_bytes() -
                         resource_pool_->acquired_memory_usage_bytes());
 }
 
-bool TileManager::UpdateVisibleTiles() {
+void TileManager::UpdateVisibleTiles() {
   TRACE_EVENT0("cc", "TileManager::UpdateVisibleTiles");
 
   rasterizer_->CheckForCompletedTasks();
   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();
-
-  bool did_initialize_visible_tile = did_initialize_visible_tile_;
-  did_initialize_visible_tile_ = false;
-  return did_initialize_visible_tile;
 }
 
 scoped_refptr<base::debug::ConvertableToTraceFormat>
 TileManager::BasicStateAsValue() const {
   scoped_refptr<base::debug::TracedValue> value =
       new base::debug::TracedValue();
   BasicStateAsValueInto(value.get());
   return value;
 }
 
@@ skipping 358 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)
-    did_initialize_visible_tile_ = true;
-
   client_->NotifyTileStateChanged(tile);
 }
 
 scoped_refptr<Tile> TileManager::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) {
@@ skipping 28 matching lines @@
       return false;
   }
 
   return true;
 }
 
 bool TileManager::IsReadyToDraw() const {
   const std::vector<PictureLayerImpl*>& layers = client_->GetPictureLayers();
 
   for (std::vector<PictureLayerImpl*>::const_iterator it = layers.begin();
-       it != layers.end();
-       ++it) {
+       it != layers.end(); ++it) {
     if (!(*it)->AllTilesRequiredForDrawAreReadyToDraw())
       return false;
   }
 
   return true;
 }
 
 void TileManager::CheckIfReadyToActivate() {
   TRACE_EVENT0("cc", "TileManager::CheckIfReadyToActivate");
 
@@ skipping 58 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