cc: Adding support for RGBA_4444 tile textures

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 1627 matching lines @@
     ContextProvider* context_provider,
     bool using_map_image) {
   DCHECK(settings_.impl_side_painting);
   DCHECK(resource_provider);
   tile_manager_ =
       TileManager::Create(this,
                           resource_provider,
                           settings_.num_raster_threads,
                           rendering_stats_instrumentation_,
                           using_map_image,
-                          GetMaxTransferBufferUsageBytes(context_provider));
+                          GetMaxTransferBufferUsageBytes(context_provider),
+                          settings_.use_rgba_4444_textures);
 
   UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
   need_to_update_visible_tiles_before_draw_ = false;
 }
 
 void LayerTreeHostImpl::EnforceZeroBudget(bool zero_budget) {
   SetManagedMemoryPolicy(cached_managed_memory_policy_, zero_budget);
 }
 
 bool LayerTreeHostImpl::InitializeRenderer(
     scoped_ptr<OutputSurface> output_surface) {
   // Since we will create a new resource provider, we cannot continue to use
   // the old resources (i.e. render_surfaces and texture IDs). Clear them
   // before we destroy the old resource provider.
   ReleaseTreeResources();
   if (resource_provider_)
     resource_provider_->DidLoseOutputSurface();
 
   // Note: order is important here.
   renderer_.reset();
   tile_manager_.reset();
   resource_provider_.reset();
   output_surface_.reset();
 
   if (!output_surface->BindToClient(this))
     return false;
 
   scoped_ptr<ResourceProvider> resource_provider = ResourceProvider::Create(
-      output_surface.get(), settings_.highp_threshold_min);
+      output_surface.get(),
+      settings_.highp_threshold_min);
   if (!resource_provider)
     return false;
 
   if (output_surface->capabilities().deferred_gl_initialization)
     EnforceZeroBudget(true);
 
   bool skip_gl_renderer = false;
   CreateAndSetRenderer(
       output_surface.get(), resource_provider.get(), skip_gl_renderer);
 
@@ skipping 936 matching lines @@
       break;
   }
 
   // Allow for multiple creation requests with the same UIResourceId.  The
   // previous resource is simply deleted.
   ResourceProvider::ResourceId id = ResourceIdForUIResource(uid);
   if (id)
     DeleteUIResource(uid);
   id = resource_provider_->CreateResource(
       bitmap->GetSize(),
-      resource_provider_->best_texture_format(),
       wrap_mode,
-      ResourceProvider::TextureUsageAny);
+      ResourceProvider::TextureUsageAny,
+      resource_provider_->best_texture_format());
 
   ui_resource_map_[uid] = id;
   resource_provider_->SetPixels(id,
                                 reinterpret_cast<uint8_t*>(bitmap->GetPixels()),
                                 gfx::Rect(bitmap->GetSize()),
                                 gfx::Rect(bitmap->GetSize()),
                                 gfx::Vector2d(0, 0));
 }
 
 void LayerTreeHostImpl::DeleteUIResource(UIResourceId uid) {
@@ skipping 15 matching lines @@
 
 ResourceProvider::ResourceId LayerTreeHostImpl::ResourceIdForUIResource(
     UIResourceId uid) const {
   UIResourceMap::const_iterator iter = ui_resource_map_.find(uid);
   if (iter != ui_resource_map_.end())
     return iter->second;
   return 0;
 }
 
 }  // namespace cc