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 110 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 UPLOAD_FLUSHED_STATE:

[nduca, 2013/03/11 19:41:47]

I'm not sure I'm wild about flush as a term here. Flush means to me ~= glFlush
which means "we have submitted it" which I dont actually think is what you
intend here. Can you please come up with something more consistent in naming?

[Sami, 2013/03/12 14:13:07]

Agreed. I'll call it forced upload completion here and elsewhere like you
suggested.

+      return scoped_ptr<base::Value>(base::Value::CreateStringValue(
+          "UPLOAD_FLUSHED_STATE"));
   default:
       DCHECK(false) << "Unrecognized TileRasterState value";
       return scoped_ptr<base::Value>(base::Value::CreateStringValue(
           "<unknown TileRasterState value>"));
   }
 }
 
 ManagedTileState::ManagedTileState()
     : can_use_gpu_memory(false),
       can_be_freed(true),
@@ skipping 311 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::FlushPendingTileUploadIfNeeded(Tile* tile) {
+  ManagedTileState& managed_tile_state = tile->managed_state();
+  if (managed_tile_state.raster_state == UPLOAD_STATE) {
+    DCHECK(managed_tile_state.resource);
+    Resource* resource = managed_tile_state.resource.get();
+    resource_pool_->resource_provider()->InsertWaitForSetPixels(resource->id());
+    managed_tile_state.resource_is_being_initialized = false;
+    DidTileRasterStateChange(tile, UPLOAD_FLUSHED_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 UPLOAD_FLUSHED_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 543 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