cc: Upload cheap tiles synchronously

cc/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/tile_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 105 matching lines @@
     TileManagerClient* client,
     ResourceProvider* resource_provider,
     size_t num_raster_threads,
     bool record_rendering_stats,
     bool use_cheapness_estimator)
     : client_(client),
       resource_pool_(ResourcePool::Create(resource_provider)),
       raster_worker_pool_(RasterWorkerPool::Create(num_raster_threads, record_rendering_stats)),
       manage_tiles_pending_(false),
       manage_tiles_call_count_(0),
-      bytes_pending_set_pixels_(0),
+      bytes_pending_upload_(0),
       ever_exceeded_memory_budget_(false),
       record_rendering_stats_(record_rendering_stats),
       use_cheapness_estimator_(use_cheapness_estimator) {
   for (int i = 0; i < NUM_STATES; ++i) {
     for (int j = 0; j < NUM_TREES; ++j) {
       for (int k = 0; k < NUM_BINS; ++k)
         raster_state_count_[i][j][k] = 0;
     }
   }
 }
 
 TileManager::~TileManager() {
   // Reset global state and manage. This should cause
   // our memory usage to drop to zero.
   global_state_ = GlobalStateThatImpactsTilePriority();
   AssignGpuMemoryToTiles();
   // This should finish all pending tasks and release any uninitialized
   // resources.
   raster_worker_pool_.reset();
   CheckForCompletedTileUploads();
-  DCHECK(tiles_with_pending_set_pixels_.size() == 0);
+  DCHECK(tiles_with_pending_upload_.size() == 0);
   DCHECK(tiles_.size() == 0);
 }
 
 void TileManager::SetGlobalState(
     const GlobalStateThatImpactsTilePriority& global_state) {
   global_state_ = global_state;
   resource_pool_->SetMaxMemoryUsageBytes(global_state_.memory_limit_in_bytes);
   ScheduleManageTiles();
 }
 
@@ skipping 149 matching lines @@
   // Assign gpu memory and determine what tiles need to be rasterized.
   AssignGpuMemoryToTiles();
 
   TRACE_EVENT_INSTANT1("cc", "DidManage", "state", ValueToString(AsValue()));
 
   // Finally, kick the rasterizer.
   DispatchMoreTasks();
 }
 
 void TileManager::CheckForCompletedTileUploads() {
-  while (!tiles_with_pending_set_pixels_.empty()) {
-    Tile* tile = tiles_with_pending_set_pixels_.front();
+  while (!tiles_with_pending_upload_.empty()) {
+    Tile* tile = tiles_with_pending_upload_.front();
     DCHECK(tile->managed_state().resource);
 
     // Set pixel tasks complete in the order they are posted.
     if (!resource_pool_->resource_provider()->didSetPixelsComplete(
           tile->managed_state().resource->id())) {
       break;
     }
 
-    if (tile->priority(ACTIVE_TREE).distance_to_visible_in_pixels == 0 &&
-        tile->priority(ACTIVE_TREE).resolution == HIGH_RESOLUTION)
-      client_->DidUploadVisibleHighResolutionTile();
-
     // It's now safe to release the pixel buffer.
     resource_pool_->resource_provider()->releasePixelBuffer(
         tile->managed_state().resource->id());
 
-    DidFinishTileInitialization(tile);
+    DidCompleteTileUpload(tile);
 
-    bytes_pending_set_pixels_ -= tile->bytes_consumed_if_allocated();
-    DidTileRasterStateChange(tile, IDLE_STATE);
-    tiles_with_pending_set_pixels_.pop();
+    bytes_pending_upload_ -= tile->bytes_consumed_if_allocated();
+    tiles_with_pending_upload_.pop();
   }
 
   DispatchMoreTasks();
 }
 
+void TileManager::DidCompleteTileUpload(Tile* tile) {
+  if (tile->priority(ACTIVE_TREE).distance_to_visible_in_pixels == 0 &&
+      tile->priority(ACTIVE_TREE).resolution == HIGH_RESOLUTION)
+    client_->DidUploadVisibleHighResolutionTile();
+
+  DidFinishTileInitialization(tile);
+  DidTileRasterStateChange(tile, IDLE_STATE);
+}
+
 void TileManager::GetMemoryStats(
     size_t* memoryRequiredBytes,
     size_t* memoryNiceToHaveBytes,
     size_t* memoryUsedBytes) const {
   *memoryRequiredBytes = 0;
   *memoryNiceToHaveBytes = 0;
   *memoryUsedBytes = 0;
   for(size_t i = 0; i < tiles_.size(); i++) {
     const Tile* tile = tiles_[i];
     const ManagedTileState& mts = tile->managed_state();
@@ skipping 45 matching lines @@
 
 bool TileManager::HasPendingWorkScheduled(WhichTree tree) const {
   // Always true when ManageTiles() call is pending.
   if (manage_tiles_pending_)
     return true;
 
   for (int i = 0; i < NUM_STATES; ++i) {
     switch (i) {
       case WAITING_FOR_RASTER_STATE:
       case RASTER_STATE:
-      case SET_PIXELS_STATE:
+      case UPLOAD_STATE:
         for (int j = 0; j < NEVER_BIN; ++j) {
           if (raster_state_count_[i][tree][j])
             return true;
         }
         break;
       case IDLE_STATE:
         break;
       default:
         NOTREACHED();
     }
@@ skipping 86 matching lines @@
 void TileManager::FreeResourcesForTile(Tile* tile) {
   ManagedTileState& managed_tile_state = tile->managed_state();
   DCHECK(managed_tile_state.can_be_freed);
   if (managed_tile_state.resource)
     resource_pool_->ReleaseResource(managed_tile_state.resource.Pass());
 }
 
 bool TileManager::CanDispatchRasterTask(Tile* tile) const {
   if (raster_worker_pool_->IsBusy())
     return false;
-  size_t new_bytes_pending = bytes_pending_set_pixels_;
+  size_t new_bytes_pending = bytes_pending_upload_;
   new_bytes_pending += tile->bytes_consumed_if_allocated();
   return new_bytes_pending <= kMaxPendingUploadBytes;
 }
 
 bool TileManager::CanPerformCheapRaster(Tile* tile) const {
   if (!use_cheapness_estimator_ || !client_->CanDoAnotherCheapRaster())
     return false;
   ManagedTileState& managed_state = tile->managed_state();
   DCHECK(managed_state.pending_pixel_refs.empty());
-  size_t new_bytes_pending = bytes_pending_set_pixels_;
-  new_bytes_pending += tile->bytes_consumed_if_allocated();
-  if (new_bytes_pending > kMaxPendingUploadBytes)
-    return false;
   return tile->picture_pile()->IsCheapInRect(tile->content_rect_,
                                              tile->contents_scale());
 }
 
 void TileManager::DispatchMoreTasks() {
   // Because tiles in the image decoding list have higher priorities, we
   // need to process those tiles first before we start to handle the tiles
   // in the need_to_be_rasterized queue.
   for(TileList::iterator it = tiles_with_image_decoding_tasks_.begin();
       it != tiles_with_image_decoding_tasks_.end(); ) {
@@ skipping 153 matching lines @@
   scoped_ptr<ResourcePool::Resource> resource = PrepareTileForRaster(tile);
   ResourceProvider::ResourceId resource_id = resource->id();
 
   PerformRaster(resource_pool_->resource_provider()->mapPixelBuffer(
                     resource_id),
                 tile->content_rect_,
                 tile->contents_scale(),
                 use_cheapness_estimator_,
                 tile->picture_pile(),
                 &rendering_stats_);
-  OnRasterCompleted(tile, resource.Pass(), manage_tiles_call_count_);
+  OnRasterCompleted(tile, resource.Pass(), manage_tiles_call_count_,
+                    TILE_UPLOAD_SYNC);
   client_->DidPerformCheapRaster();
 }
 
 void TileManager::OnRasterCompleted(
     scoped_refptr<Tile> tile,
     scoped_ptr<ResourcePool::Resource> resource,
-    int manage_tiles_call_count_when_dispatched) {
+    int manage_tiles_call_count_when_dispatched,
+    TileUploadMethod upload_method) {
   TRACE_EVENT0("cc", "TileManager::OnRasterCompleted");
 
   // Release raster resources.
   resource_pool_->resource_provider()->unmapPixelBuffer(resource->id());
 
   ManagedTileState& managed_tile_state = tile->managed_state();
   managed_tile_state.can_be_freed = true;
 
   // Tile can be freed after the completion of the raster task. Call
   // AssignGpuMemoryToTiles() to re-assign gpu memory to highest priority
   // tiles if ManageTiles() was called since task was dispatched. The result
   // of this could be that this tile is no longer allowed to use gpu
   // memory and in that case we need to abort initialization and free all
   // associated resources before calling DispatchMoreTasks().
   if (manage_tiles_call_count_when_dispatched != manage_tiles_call_count_)
     AssignGpuMemoryToTiles();
 
   // Finish resource initialization if |can_use_gpu_memory| is true.
   if (managed_tile_state.can_use_gpu_memory) {
     // The component order may be bgra if we're uploading bgra pixels to rgba
     // texture. Mark contents as swizzled if image component order is
     // different than texture format.
     managed_tile_state.contents_swizzled =
         !PlatformColor::sameComponentOrder(tile->format_);
 
-    // Tile resources can't be freed until upload has completed.
-    managed_tile_state.can_be_freed = false;
+    if (upload_method == TILE_UPLOAD_ASYNC) {
+      // Tile resources can't be freed until upload has completed.
+      managed_tile_state.can_be_freed = false;
 
-    resource_pool_->resource_provider()->beginSetPixels(resource->id());
-    resource_pool_->resource_provider()->shallowFlushIfSupported();
-    managed_tile_state.resource = resource.Pass();
+      resource_pool_->resource_provider()->beginSetPixels(resource->id());
+      resource_pool_->resource_provider()->shallowFlushIfSupported();
+      managed_tile_state.resource = resource.Pass();
 
-    bytes_pending_set_pixels_ += tile->bytes_consumed_if_allocated();
-    DidTileRasterStateChange(tile, SET_PIXELS_STATE);
-    tiles_with_pending_set_pixels_.push(tile);
+      bytes_pending_upload_ += tile->bytes_consumed_if_allocated();
+      DidTileRasterStateChange(tile, UPLOAD_STATE);
+      tiles_with_pending_upload_.push(tile);
+    } else {
+      DCHECK(upload_method == TILE_UPLOAD_SYNC);
+      resource_pool_->resource_provider()->setPixelsFromBuffer(resource->id());
+      resource_pool_->resource_provider()->releasePixelBuffer(resource->id());
+      managed_tile_state.resource = resource.Pass();
+      DidCompleteTileUpload(tile);
+    }
   } else {
     resource_pool_->resource_provider()->releasePixelBuffer(resource->id());
     resource_pool_->ReleaseResource(resource.Pass());
     managed_tile_state.resource_is_being_initialized = false;
     DidTileRasterStateChange(tile, IDLE_STATE);
   }
 }
 
 void TileManager::OnRasterTaskCompleted(
     scoped_refptr<Tile> tile,
     scoped_ptr<ResourcePool::Resource> resource,
     int manage_tiles_call_count_when_dispatched) {
   OnRasterCompleted(tile, resource.Pass(),
-                    manage_tiles_call_count_when_dispatched);
+                    manage_tiles_call_count_when_dispatched,
+                    TILE_UPLOAD_ASYNC);
   DispatchMoreTasks();
 }
 
 void TileManager::DidFinishTileInitialization(Tile* tile) {
   ManagedTileState& managed_tile_state = tile->managed_state();
   DCHECK(managed_tile_state.resource);
   managed_tile_state.resource_is_being_initialized = false;
   managed_tile_state.can_be_freed = true;
 }
 
@@ skipping 93 matching lines @@
     decode_begin_time = base::TimeTicks::Now();
   pixel_ref->Decode();
   if (stats) {
     stats->totalDeferredImageDecodeCount++;
     stats->totalDeferredImageDecodeTime +=
         base::TimeTicks::Now() - decode_begin_time;
   }
 }
 
 }  // namespace cc