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 238 matching lines @@
       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,
+                                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);
@@ skipping 45 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