cc: Fix BytesPerPixel issue and refactor.

cc/resources/resource_util.cc

Index: cc/resources/resource_util.cc
diff --git a/cc/resources/resource_util.cc b/cc/resources/resource_util.cc
new file mode 100644
index 0000000000000000000000000000000000000000..df23e793be4dd923f1bdbdefd8741da46c12fea5
--- /dev/null
+++ b/cc/resources/resource_util.cc
@@ -0,0 +1,63 @@
+// Copyright 2015 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/resource_util.h"
+
+#include "base/numerics/safe_math.h"
+#include "cc/base/math_util.h"
+
+namespace cc {
+
+// static
+bool ResourceUtil::VerifySizeInBytes(const gfx::Size& size,
+                                     ResourceFormat format) {
+  base::CheckedNumeric<size_t> checked_value = BitsPerPixel(format);
+  checked_value *= size.width();
+  checked_value *= size.height();
+  if (!checked_value.IsValid())
+    return false;
+  size_t value = checked_value.ValueOrDie();
+  if ((value % 8) != 0)
+    return false;
+  return true;
+}
+
+// static
+size_t ResourceUtil::CheckedSizeInBytes(const gfx::Size& size,

[vmpstr, 2015/07/14 17:44:15]

I'd weakly prefer SizeInBytes to be the checked version and UncheckedSizeInBytes
to be the unchecked one. This makes it clear that if the author is using
Unchecked, then they have reasoned out why we don't have to worry about
overflow. 

[prashant.n, 2015/07/15 07:03:31]

You mean to say - instead of SizeInBytes, use UncheckedSizeInBytes?

[vmpstr, 2015/07/15 17:43:22]

Yeah, just a function rename. If it's just Foo it should be safe (protected
against overflow), if it's UncheckedFoo, then it's clear that this function can
overflow if the input isn't controlled. 

+                                        ResourceFormat format) {
+  DCHECK(VerifySizeInBytes(size, format));
+  base::CheckedNumeric<size_t> checked_value = BitsPerPixel(format);
+  checked_value *= size.width();
+  checked_value *= size.height();
+  checked_value /= 8;
+  return checked_value.ValueOrDie();
+}
+
+// static
+size_t ResourceUtil::WidthInBytes(size_t width, ResourceFormat format) {
+  size_t bytes_per_row = width * static_cast<size_t>(BitsPerPixel(format)) / 8;
+  return bytes_per_row;
+}
+
+// static
+size_t ResourceUtil::SizeInBytes(const gfx::Size& size, ResourceFormat format) {
+  DCHECK(VerifySizeInBytes(size, format));
+  return size.height() * WidthInBytes(size.width(), format);
+}
+
+// static
+size_t ResourceUtil::WidthInBytesAligned(size_t width, ResourceFormat format) {
+  // Use 4-byte row alignment (OpenGL default) for upload performance.
+  // Assuming that GL_UNPACK_ALIGNMENT has not changed from default.
+  return MathUtil::RoundUp<size_t>(WidthInBytes(width, format), 4u);
+}
+
+// static
+size_t ResourceUtil::SizeInBytesAligned(const gfx::Size& size,
+                                        ResourceFormat format) {
+  DCHECK(VerifySizeInBytes(size, format));
+  return size.height() * WidthInBytesAligned(size.width(), format);
+}
+
+}  // namespace cc