cc: Complete pending tile uploads if they are needed for tree activation

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 119 matching lines @@
           "IDLE_STATE"));
   case WAITING_FOR_RASTER_STATE:
       return scoped_ptr<base::Value>(base::Value::CreateStringValue(
           "WAITING_FOR_RASTER_STATE"));
   case RASTER_STATE:
       return scoped_ptr<base::Value>(base::Value::CreateStringValue(
           "RASTER_STATE"));
   case UPLOAD_STATE:
       return scoped_ptr<base::Value>(base::Value::CreateStringValue(
           "UPLOAD_STATE"));
+  case FORCED_UPLOAD_COMPLETION_STATE:
+      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
+          "FORCED_UPLOAD_COMPLETION_STATE"));
   default:
       DCHECK(false) << "Unrecognized TileRasterState value";
       return scoped_ptr<base::Value>(base::Value::CreateStringValue(
           "<unknown TileRasterState value>"));
   }
 }
 
 TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
@@ skipping 271 matching lines @@
     DidTileRasterStateChange(tile, IDLE_STATE);
     tiles_with_pending_upload_.pop();
   }
 }
 
 void TileManager::DidCompleteFrame() {
   allow_cheap_tasks_ = true;
   did_schedule_cheap_tasks_ = false;
 }
 
+void TileManager::ForceTileUploadToComplete(Tile* tile) {
+  ManagedTileState& managed_tile_state = tile->managed_state();
+  if (managed_tile_state.raster_state == UPLOAD_STATE) {
+    Resource* resource = tile->drawing_info().resource_.get();
+    DCHECK(resource);
+    resource_pool_->resource_provider()->
+        ForceSetPixelsToComplete(resource->id());
+    tile->drawing_info().resource_is_being_initialized_ = false;
+    DidTileRasterStateChange(tile, FORCED_UPLOAD_COMPLETION_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 < live_or_allocated_tiles_.size(); i++) {
     const Tile* tile = live_or_allocated_tiles_[i];
     const ManagedTileState& mts = tile->managed_state();
@@ skipping 65 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 UPLOAD_STATE:
+      case FORCED_UPLOAD_COMPLETION_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 564 matching lines @@
     decode_begin_time = base::TimeTicks::HighResNow();
   pixel_ref->Decode();
   if (stats) {
     stats->totalDeferredImageDecodeCount++;
     stats->totalDeferredImageDecodeTime +=
         base::TimeTicks::HighResNow() - decode_begin_time;
   }
 }
 
 }  // namespace cc