cc: Use CheckedNumeric for resource size calculations.

cc/raster/pixel_buffer_tile_task_worker_pool.cc

 // Copyright 2013 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/raster/pixel_buffer_tile_task_worker_pool.h"
 
 #include <algorithm>
 
 #include "base/containers/stack_container.h"
 #include "base/strings/stringprintf.h"
@@ skipping 413 matching lines @@
   for (RasterTask::Vector::const_iterator it =
            tasks_with_completed_uploads.begin();
        it != tasks_with_completed_uploads.end(); ++it) {
     RasterTask* task = it->get();
     RasterTaskState::Vector::iterator state_it =
         std::find_if(raster_task_states_.begin(), raster_task_states_.end(),
                      RasterTaskState::TaskComparator(task));
     DCHECK(state_it != raster_task_states_.end());
     RasterTaskState& state = *state_it;
 
-    bytes_pending_upload_ -= task->resource()->bytes();
+    // We can use UncheckedMemorySizeBytes here, since these tasks come from
+    // tiles, the size of which is controlled by the compositor.
+    bytes_pending_upload_ -= Resource::UncheckedMemorySizeBytes(
+        task->resource()->size(), task->resource()->format());
 
     task->WillComplete();
     task->CompleteOnOriginThread(this);
     task->DidComplete();
 
     DCHECK(std::find(completed_raster_tasks_.begin(),
                      completed_raster_tasks_.end(),
                      task) == completed_raster_tasks_.end());
     completed_raster_tasks_.push_back(task);
     state.type = RasterTaskState::COMPLETED;
@@ skipping 85 matching lines @@
       DCHECK(std::find(completed_raster_tasks_.begin(),
                        completed_raster_tasks_.end(),
                        task) != completed_raster_tasks_.end());
       continue;
     }
 
     // All raster tasks need to be throttled by bytes of pending uploads,
     // but if it's the only task allow it to complete no matter what its size,
     // to prevent starvation of the task queue.
     size_t new_bytes_pending_upload = bytes_pending_upload;
-    new_bytes_pending_upload += task->resource()->bytes();
+    // We can use UncheckedMemorySizeBytes here, since these tasks come from
+    // tiles, the size of which is controlled by the compositor.
+    new_bytes_pending_upload += Resource::UncheckedMemorySizeBytes(
+        task->resource()->size(), task->resource()->format());
     if (new_bytes_pending_upload > max_bytes_pending_upload_ &&
         bytes_pending_upload) {
       did_throttle_raster_tasks |= item.task_sets;
       continue;
     }
 
     // If raster has finished, just update |bytes_pending_upload|.
     if (state.type == RasterTaskState::UPLOADING) {
       DCHECK(!task->HasCompleted());
       bytes_pending_upload = new_bytes_pending_upload;
@@ skipping 143 matching lines @@
       // Triggers if the current task belongs to a set that should be empty.
       DCHECK((state.task_sets & ~NonEmptyTaskSetsFromTaskCounts(task_counts_))
                  .none());
       RemoveTaskSetsFromTaskCounts(task_counts_, state.task_sets);
       continue;
     }
 
     resource_provider_->BeginSetPixels(raster_task->resource()->id());
     has_performed_uploads_since_last_flush_ = true;
 
-    bytes_pending_upload_ += raster_task->resource()->bytes();
+    // We can use UncheckedMemorySizeBytes here, since these tasks come from
+    // tiles, the size of which is controlled by the compositor.
+    bytes_pending_upload_ += Resource::UncheckedMemorySizeBytes(
+        raster_task->resource()->size(), raster_task->resource()->format());
     raster_tasks_with_pending_upload_.push_back(raster_task);
     state.type = RasterTaskState::UPLOADING;
   }
   completed_tasks_.clear();
 }
 
 scoped_refptr<base::trace_event::ConvertableToTraceFormat>
 PixelBufferTileTaskWorkerPool::StateAsValue() const {
   scoped_refptr<base::trace_event::TracedValue> state =
       new base::trace_event::TracedValue();
@@ skipping 16 matching lines @@
   throttle_state->SetInteger(
       "bytes_available_for_upload",
       static_cast<int>(max_bytes_pending_upload_ - bytes_pending_upload_));
   throttle_state->SetInteger("bytes_pending_upload",
                              static_cast<int>(bytes_pending_upload_));
   throttle_state->SetInteger("scheduled_raster_task_count",
                              static_cast<int>(scheduled_raster_task_count_));
 }
 
 }  // namespace cc