cc: Adding support for RGBA_4444 tile textures

cc/resources/prioritized_resource.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/prioritized_resource.h"
 
 #include <algorithm>
 
 #include "cc/resources/platform_color.h"
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/resources/priority_calculator.h"
 #include "cc/trees/proxy.h"
 
 namespace cc {
 
 PrioritizedResource::PrioritizedResource(PrioritizedResourceManager* manager,
                                          gfx::Size size,
                                          GLenum format)
     : size_(size),
       format_(format),
       bytes_(0),
       contents_swizzled_(false),
       priority_(PriorityCalculator::LowestPriority()),
       is_above_priority_cutoff_(false),
       is_self_managed_(false),
       backing_(NULL),
       manager_(NULL) {
   // manager_ is set in RegisterTexture() so validity can be checked.
   DCHECK(format || size.IsEmpty());
-  if (format)
-    bytes_ = Resource::MemorySizeBytes(size, format);
+  if (format) {
+    // TODO(kaanb): check this codepath

[enne (OOO), 2013/09/05 02:01:19]

Hopefully this codepath is not hit on Android once you got rid of the ImageLayer
for the glow?

[kaanb, 2013/09/06 02:05:54]

We'll probably disable the glow, however with the latest version of the patch it
started working again.

+    bytes_ = Resource::MemorySizeBytes(size, format, false);
+  }
   if (manager)
     manager->RegisterTexture(this);
 }
 
 PrioritizedResource::~PrioritizedResource() {
   if (manager_)
     manager_->UnregisterTexture(this);
 }
 
 void PrioritizedResource::SetTextureManager(
     PrioritizedResourceManager* manager) {
   if (manager_ == manager)
     return;
   if (manager_)
     manager_->UnregisterTexture(this);
   if (manager)
     manager->RegisterTexture(this);
 }
 
 void PrioritizedResource::SetDimensions(gfx::Size size, GLenum format) {
   if (format_ != format || size_ != size) {
     is_above_priority_cutoff_ = false;
     format_ = format;
     size_ = size;
-    bytes_ = Resource::MemorySizeBytes(size, format);
+    bytes_ = Resource::MemorySizeBytes(size, format, false);
     DCHECK(manager_ || !backing_);
     if (manager_)
       manager_->ReturnBackingTexture(this);
   }
 }
 
 bool PrioritizedResource::RequestLate() {
   if (!manager_)
     return false;
   return manager_->RequestLate(this);
@@ skipping 48 matching lines @@
 void PrioritizedResource::SetToSelfManagedMemoryPlaceholder(size_t bytes) {
   SetDimensions(gfx::Size(), GL_RGBA);
   set_is_self_managed(true);
   bytes_ = bytes;
 }
 
 PrioritizedResource::Backing::Backing(unsigned id,
                                       ResourceProvider* resource_provider,
                                       gfx::Size size,
                                       GLenum format)
-    : Resource(id, size, format),
+    : Resource(id, size, format, false),
       owner_(NULL),
       priority_at_last_priority_update_(PriorityCalculator::LowestPriority()),
       was_above_priority_cutoff_at_last_priority_update_(false),
       in_drawing_impl_tree_(false),
 #ifdef NDEBUG
       resource_has_been_deleted_(false) {}
 #else
       resource_has_been_deleted_(false),
       resource_provider_(resource_provider) {}
 #endif
@@ skipping 56 matching lines @@
     manager_->ReturnBackingTexture(this);
 }
 
 const Proxy* PrioritizedResource::Backing::proxy() const {
   if (!owner_ || !owner_->resource_manager())
     return NULL;
   return owner_->resource_manager()->ProxyForDebug();
 }
 
 }  // namespace cc