gfx: Use unsigned strides for gpu memory buffers.

gpu/ipc/client/gpu_memory_buffer_impl_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 "gpu/ipc/client/gpu_memory_buffer_impl_shared_memory.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 10 matching lines @@
 
 }  // namespace
 
 GpuMemoryBufferImplSharedMemory::GpuMemoryBufferImplSharedMemory(
     gfx::GpuMemoryBufferId id,
     const gfx::Size& size,
     gfx::BufferFormat format,
     const DestructionCallback& callback,
     std::unique_ptr<base::SharedMemory> shared_memory,
     size_t offset,
-    int stride)
+    uint32_t stride)
     : GpuMemoryBufferImpl(id, size, format, callback),
       shared_memory_(std::move(shared_memory)),
       offset_(offset),
       stride_(stride) {
   DCHECK(IsSizeValidForFormat(size, format));
 }
 
 GpuMemoryBufferImplSharedMemory::~GpuMemoryBufferImplSharedMemory() {}
 
 // static
@@ skipping 27 matching lines @@
     return gfx::GpuMemoryBufferHandle();
 
   base::SharedMemory shared_memory;
   if (!shared_memory.CreateAnonymous(buffer_size))
     return gfx::GpuMemoryBufferHandle();
 
   gfx::GpuMemoryBufferHandle handle;
   handle.type = gfx::SHARED_MEMORY_BUFFER;
   handle.id = id;
   handle.offset = 0;
-  handle.stride = static_cast<int32_t>(
+  handle.stride = static_cast<uint32_t>(
       gfx::RowSizeForBufferFormat(size.width(), format, 0));
   shared_memory.GiveToProcess(child_process, &handle.handle);
   return handle;
 }
 
 // static
 std::unique_ptr<GpuMemoryBufferImplSharedMemory>
 GpuMemoryBufferImplSharedMemory::CreateFromHandle(
     const gfx::GpuMemoryBufferHandle& handle,
     const gfx::Size& size,
@@ skipping 73 matching lines @@
     const gfx::Size& size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     gfx::GpuMemoryBufferHandle* handle) {
   base::SharedMemory shared_memory;
   bool rv = shared_memory.CreateAnonymous(
       gfx::BufferSizeForBufferFormat(size, format));
   DCHECK(rv);
   handle->type = gfx::SHARED_MEMORY_BUFFER;
   handle->offset = 0;
-  handle->stride = static_cast<int32_t>(
+  handle->stride = static_cast<uint32_t>(
       gfx::RowSizeForBufferFormat(size.width(), format, 0));
   handle->handle = base::SharedMemory::DuplicateHandle(shared_memory.handle());
   return base::Bind(&Noop);
 }
 
 bool GpuMemoryBufferImplSharedMemory::Map() {
   DCHECK(!mapped_);
 
   // Map the buffer first time Map() is called then keep it mapped for the
   // lifetime of the buffer. This avoids mapping the buffer unless necessary.
@@ skipping 16 matching lines @@
   DCHECK_LT(plane, gfx::NumberOfPlanesForBufferFormat(format_));
   return reinterpret_cast<uint8_t*>(shared_memory_->memory()) + offset_ +
          gfx::BufferOffsetForBufferFormat(size_, format_, plane);
 }
 
 void GpuMemoryBufferImplSharedMemory::Unmap() {
   DCHECK(mapped_);
   mapped_ = false;
 }
 
-int GpuMemoryBufferImplSharedMemory::stride(size_t plane) const {
+uint32_t GpuMemoryBufferImplSharedMemory::stride(size_t plane) const {
   DCHECK_LT(plane, gfx::NumberOfPlanesForBufferFormat(format_));
   return gfx::RowSizeForBufferFormat(size_.width(), format_, plane);
 }
 
 gfx::GpuMemoryBufferHandle GpuMemoryBufferImplSharedMemory::GetHandle() const {
   gfx::GpuMemoryBufferHandle handle;
   handle.type = gfx::SHARED_MEMORY_BUFFER;
   handle.id = id_;
   handle.offset = offset_;
   handle.stride = stride_;
   handle.handle = shared_memory_->handle();
   return handle;
 }
 
 }  // namespace gpu