cc: Use CheckedNumeric for resource size calculations.

cc/resources/prioritized_resource_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/prioritized_resource_manager.h"
 
 #include <algorithm>
 
 #include "base/trace_event/trace_event.h"
 #include "cc/resources/prioritized_resource.h"
@@ skipping 52 matching lines @@
   // statistics.
   memory_visible_bytes_ = 0;
   memory_visible_and_nearby_bytes_ = 0;
   for (TextureSet::iterator it = textures_.begin(); it != textures_.end();
        ++it) {
     PrioritizedResource* texture = (*it);
     sorted_textures.push_back(texture);
     if (PriorityCalculator::priority_is_higher(
             texture->request_priority(),
             PriorityCalculator::AllowVisibleOnlyCutoff()))
-      memory_visible_bytes_ += texture->bytes();
+      memory_visible_bytes_ += Resource::UncheckedMemorySizeBytes(
+          texture->size(), texture->format());
     if (PriorityCalculator::priority_is_higher(
             texture->request_priority(),
             PriorityCalculator::AllowVisibleAndNearbyCutoff()))
-      memory_visible_and_nearby_bytes_ += texture->bytes();
+      memory_visible_and_nearby_bytes_ += Resource::UncheckedMemorySizeBytes(
+          texture->size(), texture->format());
   }
   std::sort(sorted_textures.begin(), sorted_textures.end(), CompareTextures);
 
   // Compute a priority cutoff based on memory pressure
   memory_available_bytes_ = max_memory_limit_bytes_;
   priority_cutoff_ = external_priority_cutoff_;
   size_t memory_bytes = 0;
   for (TextureVector::iterator it = sorted_textures.begin();
        it != sorted_textures.end();
        ++it) {
+    size_t texture_bytes =
+        Resource::UncheckedMemorySizeBytes((*it)->size(), (*it)->format());
     if ((*it)->is_self_managed()) {
       // Account for self-managed memory immediately by reducing the memory
       // available (since it never gets acquired).
-      size_t new_memory_bytes = memory_bytes + (*it)->bytes();
+      size_t new_memory_bytes = memory_bytes + texture_bytes;
       if (new_memory_bytes > memory_available_bytes_) {
         priority_cutoff_ = (*it)->request_priority();
         memory_available_bytes_ = memory_bytes;
         break;
       }
-      memory_available_bytes_ -= (*it)->bytes();
+      memory_available_bytes_ -= texture_bytes;
     } else {
-      size_t new_memory_bytes = memory_bytes + (*it)->bytes();
+      size_t new_memory_bytes = memory_bytes + texture_bytes;
       if (new_memory_bytes > memory_available_bytes_) {
         priority_cutoff_ = (*it)->request_priority();
         break;
       }
       memory_bytes = new_memory_bytes;
     }
   }
 
   // Disallow any textures with priority below the external cutoff to have
   // backings.
@@ skipping 13 matching lines @@
   max_memory_needed_bytes_ = 0;
   memory_above_cutoff_bytes_ = 0;
   for (TextureVector::iterator it = sorted_textures.begin();
        it != sorted_textures.end();
        ++it) {
     PrioritizedResource* resource = *it;
     bool is_above_priority_cutoff = PriorityCalculator::priority_is_higher(
         resource->request_priority(), priority_cutoff_);
     resource->set_above_priority_cutoff(is_above_priority_cutoff);
     if (!resource->is_self_managed()) {
-      max_memory_needed_bytes_ += resource->bytes();
+      size_t resource_bytes = Resource::UncheckedMemorySizeBytes(
+          resource->size(), resource->format());
+      max_memory_needed_bytes_ += resource_bytes;
       if (is_above_priority_cutoff)
-        memory_above_cutoff_bytes_ += resource->bytes();
+        memory_above_cutoff_bytes_ += resource_bytes;
     }
   }
   sorted_textures.clear();
 
   DCHECK_LE(memory_above_cutoff_bytes_, memory_available_bytes_);
   DCHECK_LE(MemoryAboveCutoffBytes(), MaxMemoryLimitBytes());
 }
 
 void PrioritizedResourceManager::PushTexturePrioritiesToBackings() {
   TRACE_EVENT0("cc",
@@ skipping 63 matching lines @@
   if (PriorityCalculator::priority_is_lower(texture->request_priority(),
                                             priority_cutoff_))
     return false;
 
   // Disallow textures that do not have a priority strictly higher than the
   // external cutoff.
   if (!PriorityCalculator::priority_is_higher(texture->request_priority(),
                                               external_priority_cutoff_))
     return false;
 
-  size_t new_memory_bytes = memory_above_cutoff_bytes_ + texture->bytes();
+  size_t new_memory_bytes =
+      memory_above_cutoff_bytes_ +
+      Resource::UncheckedMemorySizeBytes(texture->size(), texture->format());
   if (new_memory_bytes > memory_available_bytes_)
     return false;
 
   memory_above_cutoff_bytes_ = new_memory_bytes;
   texture->set_above_priority_cutoff(true);
   return true;
 }
 
 void PrioritizedResourceManager::AcquireBackingTextureIfNeeded(
     PrioritizedResource* texture,
@@ skipping 17 matching lines @@
     if ((*it)->size() == texture->size() &&
         (*it)->format() == texture->format()) {
       backing = (*it);
       backings_.erase(it);
       break;
     }
   }
 
   // Otherwise reduce memory and just allocate a new backing texures.
   if (!backing) {
-    EvictBackingsToReduceMemory(memory_available_bytes_ - texture->bytes(),
-                                PriorityCalculator::AllowEverythingCutoff(),
-                                EVICT_ONLY_RECYCLABLE,
-                                DO_NOT_UNLINK_BACKINGS,
-                                resource_provider);
+    EvictBackingsToReduceMemory(
+        memory_available_bytes_ - Resource::UncheckedMemorySizeBytes(
+                                      texture->size(), texture->format()),
+        PriorityCalculator::AllowEverythingCutoff(), EVICT_ONLY_RECYCLABLE,
+        DO_NOT_UNLINK_BACKINGS, resource_provider);
     backing =
         CreateBacking(texture->size(), texture->format(), resource_provider);
   }
 
   // Move the used backing to the end of the eviction list, and note that
   // the tail is not sorted.
   if (backing->owner())
     backing->owner()->Unlink();
   texture->Link(backing);
   backings_.push_back(backing);
@@ skipping 44 matching lines @@
   // we really need very little memory. This should probably be solved by
   // reducing the limit externally, but until then this just does some "clean
   // up" of unused backing textures (any more than 10%).
   size_t wasted_memory = 0;
   for (BackingList::iterator it = backings_.begin(); it != backings_.end();
        ++it) {
     if ((*it)->owner())
       break;
     if ((*it)->in_parent_compositor())
       continue;
-    wasted_memory += (*it)->bytes();
+    wasted_memory +=
+        Resource::UncheckedMemorySizeBytes((*it)->size(), (*it)->format());
   }
   size_t wasted_memory_to_allow = memory_available_bytes_ / 10;
   // If the external priority cutoff indicates that unused memory should be
   // freed, then do not allow any memory for texture recycling.
   if (external_priority_cutoff_ != PriorityCalculator::AllowEverythingCutoff())
     wasted_memory_to_allow = 0;
   if (wasted_memory > wasted_memory_to_allow)
     EvictBackingsToReduceMemory(MemoryUseBytes() -
                                 (wasted_memory - wasted_memory_to_allow),
                                 PriorityCalculator::AllowEverythingCutoff(),
@@ skipping 110 matching lines @@
     const gfx::Size& size,
     ResourceFormat format,
     ResourceProvider* resource_provider) {
   DCHECK(proxy_->IsImplThread() && proxy_->IsMainThreadBlocked());
   DCHECK(resource_provider);
   ResourceId resource_id = resource_provider->CreateManagedResource(
       size, GL_TEXTURE_2D, GL_CLAMP_TO_EDGE,
       ResourceProvider::TEXTURE_HINT_IMMUTABLE, format);
   PrioritizedResource::Backing* backing = new PrioritizedResource::Backing(
       resource_id, resource_provider, size, format);
-  memory_use_bytes_ += backing->bytes();
+  memory_use_bytes_ +=
+      Resource::UncheckedMemorySizeBytes(backing->size(), backing->format());
   return backing;
 }
 
 void PrioritizedResourceManager::EvictFirstBackingResource(
     ResourceProvider* resource_provider) {
   DCHECK(proxy_->IsImplThread());
   DCHECK(resource_provider);
   DCHECK(!backings_.empty());
   PrioritizedResource::Backing* backing = backings_.front();
 
   // Note that we create a backing and its resource at the same time, but we
   // delete the backing structure and its resource in two steps. This is because
   // we can delete the resource while the main thread is running, but we cannot
   // unlink backings while the main thread is running.
   backing->DeleteResource(resource_provider);
-  memory_use_bytes_ -= backing->bytes();
+  memory_use_bytes_ -=
+      Resource::UncheckedMemorySizeBytes(backing->size(), backing->format());
   backings_.pop_front();
   base::AutoLock scoped_lock(evicted_backings_lock_);
   evicted_backings_.push_back(backing);
 }
 
 void PrioritizedResourceManager::AssertInvariants() {
 #if DCHECK_IS_ON()
   DCHECK(proxy_->IsImplThread() && proxy_->IsMainThreadBlocked());
 
   // If we hit any of these asserts, there is a bug in this class. To see
@@ skipping 53 matching lines @@
     previous_backing = backing;
   }
 #endif  // DCHECK_IS_ON()
 }
 
 const Proxy* PrioritizedResourceManager::ProxyForDebug() const {
   return proxy_;
 }
 
 }  // namespace cc