Update GPU memory buffers to use StrideInBytes internally.

ui/gl/gl_image_shared_memory.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 "ui/gl/gl_image_shared_memory.h"
 
 #include "base/logging.h"
 #include "base/numerics/safe_math.h"
 #include "base/process/process_handle.h"
 
 namespace gfx {
 namespace {
 
 // Returns true if the size is valid and false otherwise.
 bool SizeInBytes(const gfx::Size& size,
                  gfx::GpuMemoryBuffer::Format format,
                  size_t* size_in_bytes) {
   if (size.IsEmpty())
     return false;
-  base::CheckedNumeric<size_t> s = GLImageMemory::BytesPerPixel(format);
+  DCHECK_EQ(size.GetArea() * GLImageMemory::BitsPerPixel(format) % 8, 0u);

[reveman, 2014/12/15 17:33:34]

Hm, so this will fail for a 1x1 buffer with bpp < 8. Is that what we want? Are
not all buffer sizes support with compressed formats? In that case, how are we
protecting against a malicious renderer using an invalid size and causing
undefined behavior on the browser or GPU process side? 

[christiank, 2014/12/16 12:02:52]

Currently we don't support images with a width and height not evenly dividable
by 4 so yes, under that premise we expect this to fail.

We try to avoid this by never compressing images that don't meet the criteria.
We currently have checks for this in the tile manager. However, that doesn't
protect us against a malicious renderer. Maybe a CHECK is more appropriate here?

[reveman, 2014/12/16 16:40:12]

A renderer should not be able cause the GPU service to crash. I think if you
replace GLImageMemory::BitsPerPixel with GLImageMemory::StrideInBytes the
problem will just go away as Map() will fail if size/format combination is
invalid.

+  base::CheckedNumeric<size_t> s = GLImageMemory::BitsPerPixel(format);
   s *= size.width();
   s *= size.height();
+  s /= 8;
   if (!s.IsValid())
     return false;
   *size_in_bytes = s.ValueOrDie();
   return true;
 }
 
 }  // namespace
 
 GLImageSharedMemory::GLImageSharedMemory(const gfx::Size& size,
                                          unsigned internalformat)
@@ skipping 39 matching lines @@
   shared_memory_ = duped_shared_memory.Pass();
   return true;
 }
 
 void GLImageSharedMemory::Destroy(bool have_context) {
   GLImageMemory::Destroy(have_context);
   shared_memory_.reset();
 }
 
 }  // namespace gfx