gfx: Use unsigned strides for gpu memory buffers.

services/ui/public/cpp/mojo_gpu_memory_buffer.cc

 // 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 "services/ui/public/cpp/mojo_gpu_memory_buffer.h"
 
 #include <stdint.h>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 25 matching lines @@
   size_t shared_memory_size;
   bool readonly;
   MojoResult result = mojo::UnwrapSharedMemoryHandle(
       std::move(handle), &platform_handle, &shared_memory_size, &readonly);
   if (result != MOJO_RESULT_OK)
     return nullptr;
   DCHECK_EQ(shared_memory_size, bytes);
 
   auto shared_memory =
       base::MakeUnique<base::SharedMemory>(platform_handle, readonly);
-  const int stride = base::checked_cast<int>(
+  const uint32_t stride = base::checked_cast<uint32_t>(
       gfx::RowSizeForBufferFormat(size.width(), format, 0));
   return base::WrapUnique(new MojoGpuMemoryBufferImpl(
       size, format, std::move(shared_memory), 0, stride));
 }
 
 // static
 std::unique_ptr<gfx::GpuMemoryBuffer> MojoGpuMemoryBufferImpl::CreateFromHandle(
     const gfx::GpuMemoryBufferHandle& handle,
     const gfx::Size& size,
     gfx::BufferFormat format,
@@ skipping 34 matching lines @@
   return reinterpret_cast<uint8_t*>(shared_memory_->memory()) + offset_ +
          gfx::BufferOffsetForBufferFormat(size_, format_, plane);
 }
 
 void MojoGpuMemoryBufferImpl::Unmap() {
   DCHECK(mapped_);
   shared_memory_->Unmap();
   mapped_ = false;
 }
 
-int MojoGpuMemoryBufferImpl::stride(size_t plane) const {
+uint32_t MojoGpuMemoryBufferImpl::stride(size_t plane) const {
   DCHECK_LT(plane, gfx::NumberOfPlanesForBufferFormat(format_));
-  return base::checked_cast<int>(gfx::RowSizeForBufferFormat(
+  return base::checked_cast<uint32_t>(gfx::RowSizeForBufferFormat(
       size_.width(), format_, static_cast<int>(plane)));
 }
 
 gfx::GpuMemoryBufferHandle MojoGpuMemoryBufferImpl::GetHandle() const {
   gfx::GpuMemoryBufferHandle handle;
   handle.type = gfx::SHARED_MEMORY_BUFFER;
   handle.handle = shared_memory_->handle();
   handle.offset = offset_;
   handle.stride = stride_;
 
   return handle;
 }
 
 gfx::GpuMemoryBufferType MojoGpuMemoryBufferImpl::GetBufferType() const {
   return gfx::SHARED_MEMORY_BUFFER;
 }
 
 MojoGpuMemoryBufferImpl::MojoGpuMemoryBufferImpl(
     const gfx::Size& size,
     gfx::BufferFormat format,
     std::unique_ptr<base::SharedMemory> shared_memory,
     uint32_t offset,
-    int32_t stride)
+    uint32_t stride)
     : GpuMemoryBufferImpl(gfx::GenericSharedMemoryId(0), size, format),
       shared_memory_(std::move(shared_memory)),
       offset_(offset),
       stride_(stride) {}
 
 }  // namespace ui