cc: Moved contents_swizzled out of TileManager

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 <string>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "cc/debug/devtools_instrumentation.h"
-#include "cc/resources/platform_color.h"
 #include "cc/resources/raster_worker_pool.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/tile.h"
 #include "third_party/skia/include/core/SkDevice.h"
 
 namespace cc {
 
 namespace {
 
 // If we raster too fast we become upload bound, and pending
@@ skipping 511 matching lines @@
       FreeResourcesForTile(tile);
       continue;
     }
     if (tile_bytes > bytes_left) {
       mts.can_use_gpu_memory = false;
       if (mts.bin[HIGH_PRIORITY_BIN] == NOW_BIN ||
           mts.bin[LOW_PRIORITY_BIN] == NOW_BIN)
           bytes_that_exceeded_memory_budget_in_now_bin += tile_bytes;
       FreeResourcesForTile(tile);
       tile->drawing_info().set_rasterize_on_demand();
-      tile->drawing_info().set_contents_swizzled(
-          !PlatformColor::SameComponentOrder(tile->format_));
       continue;
     }
     tile->drawing_info().set_use_resource();
     bytes_left -= tile_bytes;
     mts.can_use_gpu_memory = true;
     if (!tile->drawing_info().resource_ &&
         !tile->drawing_info().resource_is_being_initialized_) {
       tiles_that_need_to_be_rasterized_.push_back(tile);
     }
   }
@@ skipping 193 matching lines @@
         break;
       }
     }
   }
 }
 
 scoped_ptr<ResourcePool::Resource> TileManager::PrepareTileForRaster(
     Tile* tile) {
   ManagedTileState& managed_tile_state = tile->managed_state();
   DCHECK(managed_tile_state.can_use_gpu_memory);
-  scoped_ptr<ResourcePool::Resource> resource =
-      resource_pool_->AcquireResource(tile->tile_size_.size(), tile->format_);
+  scoped_ptr<ResourcePool::Resource> resource = resource_pool_->AcquireResource(
+      tile->tile_size_.size(),
+      tile->drawing_info().resource_format_);
   resource_pool_->resource_provider()->AcquirePixelBuffer(resource->id());
 
   tile->drawing_info().resource_is_being_initialized_ = true;
   tile->drawing_info().can_be_freed_ = false;
 
   return resource.Pass();
 }
 
 void TileManager::SetAnticipatedDrawTime(base::TimeTicks time) {
   anticipated_draw_time_ = time;
@@ skipping 68 matching lines @@
   // 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();
 
   ManagedTileState& managed_tile_state = tile->managed_state();
 
   // 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.
-    tile->drawing_info().contents_swizzled_ =
-        !PlatformColor::SameComponentOrder(tile->format_);
 
     // Tile resources can't be freed until upload has completed.
     tile->drawing_info().can_be_freed_ = false;
 
     resource_pool_->resource_provider()->BeginSetPixels(resource->id());
     has_performed_uploads_since_last_flush_ = true;
 
     tile->drawing_info().resource_ = resource.Pass();
 
     bytes_pending_upload_ += tile->bytes_consumed_if_allocated();
@@ skipping 150 matching lines @@
     skia::LazyPixelRef* pixel_ref,
     RenderingStatsInstrumentation* stats_instrumentation) {
   TRACE_EVENT0("cc", "TileManager::RunImageDecodeTask");
   base::TimeTicks start_time = stats_instrumentation->StartRecording();
   pixel_ref->Decode();
   base::TimeDelta duration = stats_instrumentation->EndRecording(start_time);
   stats_instrumentation->AddDeferredImageDecode(duration);
 }
 
 }  // namespace cc