cc: Use ResourceUtil::UncheckedWidthInBytes() in CopyOnWorkerThread().

cc/raster/one_copy_tile_task_worker_pool.cc

 // Copyright 2014 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/one_copy_tile_task_worker_pool.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 307 matching lines @@
                         staging_buffer->query_id);
 #endif
     }
 
     // Since compressed texture's cannot be pre-allocated we might have an
     // unallocated resource in which case we need to perform a full size copy.
     if (IsResourceFormatCompressed(resource->format())) {
       gl->CompressedCopyTextureCHROMIUM(staging_buffer->texture_id,
                                         resource_lock->texture_id());
     } else {
-      int bytes_per_row =
-          (BitsPerPixel(resource->format()) * resource->size().width()) / 8;
+      int bytes_per_row = ResourceUtil::UncheckedWidthInBytes<int>(

[danakj, 2016/04/13 18:38:59]

If it can overflow/underflow then you want to use Checked math. Unchecked is for
when you can prove to yourself that it can't.

[reveman, 2016/04/17 20:22:59]

I don't think we want unnecessary conditionals to be executed here to check if
this overflow/underflow unless we're in a debug build. There's no reason this
should overflow/underflow unless there's a bug in our code. Unchecked seems
appropriate.

[danakj, 2016/04/18 19:47:53]

ok sg thanks, just wanted to be sure. LGTM then

+          resource->size().width(), resource->format());
       int chunk_size_in_rows =
           std::max(1, max_bytes_per_copy_operation_ / bytes_per_row);
       // Align chunk size to 4. Required to support compressed texture formats.
       chunk_size_in_rows = MathUtil::UncheckedRoundUp(chunk_size_in_rows, 4);
       int y = 0;
       int height = resource->size().height();
       while (y < height) {
         // Copy at most |chunk_size_in_rows|.
         int rows_to_copy = std::min(chunk_size_in_rows, height - y);
         DCHECK_GT(rows_to_copy, 0);
@@ skipping 29 matching lines @@
     gl->OrderingBarrierCHROMIUM();
 
     // Generate sync token after the barrier for cross context synchronization.
     gpu::SyncToken sync_token;
     gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, sync_token.GetData());
     resource_lock->UpdateResourceSyncToken(sync_token);
   }
 }
 
 }  // namespace cc