cc: Adding support for RGBA_4444 tile textures

cc/resources/resource_pool.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/resource_pool.h"
 
 #include "cc/resources/resource_provider.h"
 
 namespace cc {
 
 ResourcePool::Resource::Resource(cc::ResourceProvider* resource_provider,
                                  gfx::Size size,
-                                 GLenum format)
+                                 GLenum format,
+                                 bool use_16_bit_resource)
     : cc::Resource(resource_provider->CreateManagedResource(
                        size,
                        format,
                        ResourceProvider::TextureUsageAny),
                    size,
-                   format),
+                   format,
+                   use_16_bit_resource),
       resource_provider_(resource_provider) {
   DCHECK(id());
 }
 
 ResourcePool::Resource::~Resource() {
   DCHECK(id());
   DCHECK(resource_provider_);
   resource_provider_->DeleteResource(id());
 }
 
 ResourcePool::ResourcePool(ResourceProvider* resource_provider)
     : resource_provider_(resource_provider),
       max_memory_usage_bytes_(0),
       max_unused_memory_usage_bytes_(0),
       max_resource_count_(0),
       memory_usage_bytes_(0),
       unused_memory_usage_bytes_(0),
       resource_count_(0) {
 }
 
 ResourcePool::~ResourcePool() {
   SetResourceUsageLimits(0, 0, 0);
 }
 
 scoped_ptr<ResourcePool::Resource> ResourcePool::AcquireResource(
-    gfx::Size size, GLenum format) {
+    gfx::Size size, GLenum format, bool use_16_bit_resource) {
   for (ResourceList::iterator it = unused_resources_.begin();
        it != unused_resources_.end(); ++it) {
     Resource* resource = *it;
 
     if (!resource_provider_->CanLockForWrite(resource->id()))
       continue;
     if (resource->size() != size)
       continue;
     if (resource->format() != format)
       continue;
 
     unused_resources_.erase(it);
     unused_memory_usage_bytes_ -= resource->bytes();
     return make_scoped_ptr(resource);
   }
 
   // Create new resource.
-  Resource* resource = new Resource(resource_provider_, size, format);
+  Resource* resource = new Resource(
+      resource_provider_, size, format, use_16_bit_resource);
 
   // Extend all read locks on all resources until the resource is
   // finished being used, such that we know when resources are
   // truly safe to recycle.
   resource_provider_->EnableReadLockFences(resource->id(), true);
 
   memory_usage_bytes_ += resource->bytes();
   ++resource_count_;
   return make_scoped_ptr(resource);
 }
@@ skipping 46 matching lines @@
   if (resource_count_ > max_resource_count_)
     return true;
   if (memory_usage_bytes_ > max_memory_usage_bytes_)
     return true;
   if (unused_memory_usage_bytes_ > max_unused_memory_usage_bytes_)
     return true;
   return false;
 }
 
 }  // namespace cc