cc: Adding support for RGBA_4444 tile textures

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>
 
@@ skipping 85 matching lines @@
 
   return is_active ? EVENTUALLY_AND_ACTIVE_BIN : EVENTUALLY_BIN;
 }
 
 // Limit to the number of raster tasks that can be scheduled.
 // This is high enough to not cause unnecessary scheduling but
 // gives us an insurance that we're not spending a huge amount
 // of time scheduling one enormous set of tasks.
 const size_t kMaxRasterTasks = 256u;
 
+// static
+cc::ResourceProvider::Format GetTextureFormat(

[enne (OOO), 2013/09/13 01:39:44]

Should ResourceProvider::BestTextureFormat just take into account the
use_rgba_4444_tiles setting?

[kaanb, 2013/09/13 03:43:56]

I want to ensure we use 4444 only for tile textures for now. There are frontend
resources that need 32-bit textures even for low end devices.

+    cc::ResourceProvider* provider,
+    bool use_rgba_4444_tiles) {
+  return use_rgba_4444_tiles ? cc::ResourceProvider::RGBA_4444 :
+      provider->best_texture_format();
+}
+
 }  // namespace
 
 RasterTaskCompletionStats::RasterTaskCompletionStats()
     : completed_count(0u),
       canceled_count(0u) {
 }
 
 scoped_ptr<base::Value> RasterTaskCompletionStatsAsValue(
     const RasterTaskCompletionStats& stats) {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
   state->SetInteger("completed_count", stats.completed_count);
   state->SetInteger("canceled_count", stats.canceled_count);
   return state.PassAs<base::Value>();
 }
 
 // static
 scoped_ptr<TileManager> TileManager::Create(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
     size_t num_raster_threads,
     RenderingStatsInstrumentation* rendering_stats_instrumentation,
     bool use_map_image,
-    size_t max_transfer_buffer_usage_bytes) {
+    size_t max_transfer_buffer_usage_bytes,
+    bool use_rgba_4444_tiles) {
   return make_scoped_ptr(
       new TileManager(client,
                       resource_provider,
                       use_map_image ?
                       ImageRasterWorkerPool::Create(
                           resource_provider, num_raster_threads) :
                       PixelBufferRasterWorkerPool::Create(
                           resource_provider,
                           num_raster_threads,
-                          max_transfer_buffer_usage_bytes),
+                          max_transfer_buffer_usage_bytes,
+                          GetTextureFormat(resource_provider,
+                                           use_rgba_4444_tiles)),
                       num_raster_threads,
                       rendering_stats_instrumentation));
 }
 
 TileManager::TileManager(
     TileManagerClient* client,
     ResourceProvider* resource_provider,
     scoped_ptr<RasterWorkerPool> raster_worker_pool,
     size_t num_raster_threads,
     RenderingStatsInstrumentation* rendering_stats_instrumentation)
@@ skipping 566 matching lines @@
                  base::Unretained(pixel_ref)));
 }
 
 RasterWorkerPool::RasterTask TileManager::CreateRasterTask(Tile* tile) {
   ManagedTileState& mts = tile->managed_state();
 
   scoped_ptr<ResourcePool::Resource> resource =
       resource_pool_->AcquireResource(
           tile->tile_size_.size(),
           raster_worker_pool_->GetResourceFormat());
+
   const Resource* const_resource = resource.get();
 
   // Create and queue all image decode tasks that this tile depends on.
   RasterWorkerPool::Task::Set decode_tasks;
   PixelRefTaskMap& existing_pixel_refs = image_decode_tasks_[tile->layer_id()];
   for (PicturePileImpl::PixelRefIterator iter(tile->content_rect(),
                                               tile->contents_scale(),
                                               tile->picture_pile());
        iter; ++iter) {
     skia::LazyPixelRef* pixel_ref = *iter;
@@ skipping 95 matching lines @@
     bytes_releasable_ += tile->bytes_consumed_if_allocated();
     ++resources_releasable_;
   }
 
   FreeUnusedResourcesForTile(tile);
   if (tile->priority(ACTIVE_TREE).distance_to_visible_in_pixels == 0)
     did_initialize_visible_tile_ = true;
 }
 
 }  // namespace cc