cc: Add support for partial swaps when using impl-side painting.

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>
 
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
+#include "cc/base/math_util.h"
 #include "cc/debug/devtools_instrumentation.h"
 #include "cc/debug/traced_value.h"
 #include "cc/layers/picture_layer_impl.h"
 #include "cc/resources/direct_raster_worker_pool.h"
 #include "cc/resources/image_raster_worker_pool.h"
 #include "cc/resources/pixel_buffer_raster_worker_pool.h"
 #include "cc/resources/raster_worker_pool_delegate.h"
 #include "cc/resources/tile.h"
 #include "skia/ext/paint_simplifier.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ skipping 430 matching lines @@
       rendering_stats_instrumentation_(rendering_stats_instrumentation),
       did_initialize_visible_tile_(false),
       did_check_for_completed_tasks_since_last_schedule_tasks_(true),
       use_rasterize_on_demand_(use_rasterize_on_demand) {
   RasterWorkerPool* raster_worker_pools[NUM_RASTER_WORKER_POOL_TYPES] = {
       raster_worker_pool_.get(),        // RASTER_WORKER_POOL_TYPE_DEFAULT
       direct_raster_worker_pool_.get()  // RASTER_WORKER_POOL_TYPE_DIRECT
   };
   raster_worker_pool_delegate_ = RasterWorkerPoolDelegate::Create(
       this, raster_worker_pools, arraysize(raster_worker_pools));
+  damage_rect_ = gfx::Rect(0, 0, 0, 0);
 }
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
   // our memory usage to drop to zero.
   global_state_ = GlobalStateThatImpactsTilePriority();
 
   CleanUpReleasedTiles();
   DCHECK_EQ(0u, tiles_.size());
 
   RasterTaskQueue empty[NUM_RASTER_WORKER_POOL_TYPES];
   raster_worker_pool_delegate_->ScheduleTasks(empty);
   orphan_raster_tasks_.clear();
 
   // This should finish all pending tasks and release any uninitialized
   // resources.
   raster_worker_pool_delegate_->Shutdown();
   raster_worker_pool_delegate_->CheckForCompletedTasks();
 
   DCHECK_EQ(0u, bytes_releasable_);
   DCHECK_EQ(0u, resources_releasable_);
 
   for (std::vector<PictureLayerImpl*>::iterator it = layers_.begin();
        it != layers_.end();
        ++it) {
     (*it)->DidUnregisterLayer();
   }
   layers_.clear();
+  tilemap_.clear();
 }
 
 void TileManager::Release(Tile* tile) {
   prioritized_tiles_dirty_ = true;
   released_tiles_.push_back(tile);
 }
 
+void TileManager::ResetTileRectLayerMap() {
+  for (std::map<int, gfx::Rect>::iterator it = tilemap_.begin();
+       it != tilemap_.end();
+       ++it) {
+    it->second = gfx::Rect(0, 0, 0, 0);
+  }
+}

[reveman, 2014/04/11 18:11:34]

all this tilemap stuff is confusing and inefficient. please notify the client as
tiles get initialized instead.

[sohanjg, 2014/04/14 10:16:11]

Done.

+
+std::map<int, gfx::Rect> TileManager::GetTileRectLayerMap() { return tilemap_; }
+
 void TileManager::DidChangeTilePriority(Tile* tile) {
   prioritized_tiles_dirty_ = true;
 }
 
 bool TileManager::ShouldForceTasksRequiredForActivationToComplete() const {
   return global_state_.tree_priority != SMOOTHNESS_TAKES_PRIORITY;
 }
 
 void TileManager::CleanUpReleasedTiles() {
   for (std::vector<Tile*>::iterator it = released_tiles_.begin();
@@ skipping 715 matching lines @@
   DCHECK(tile_version.raster_task_);
   orphan_raster_tasks_.push_back(tile_version.raster_task_);
   tile_version.raster_task_ = NULL;
 
   if (was_canceled) {
     ++update_visible_tiles_stats_.canceled_count;
     resource_pool_->ReleaseResource(resource.Pass());
     return;
   }
 
+  // Maintain a map of unioned intialized tile rect and layer-id.
+  tilemap_[tile->layer_id()] =
+      gfx::UnionRects(tilemap_[tile->layer_id()], tile->content_rect());
+
   ++update_visible_tiles_stats_.completed_count;
 
   tile_version.set_has_text(analysis.has_text);
   if (analysis.is_solid_color) {
     tile_version.set_solid_color(analysis.solid_color);
     resource_pool_->ReleaseResource(resource.Pass());
   } else {
     tile_version.set_use_resource();
     tile_version.resource_ = resource.Pass();
 
@@ skipping 281 matching lines @@
                                b_tile->priority(b_pair.second),
                                false /* prioritize low res */);
   }
 
   NOTREACHED();
   // Keep the compiler happy.
   return false;
 }
 
 }  // namespace cc