ozone/drm: Only reuse ScanoutBuffers with compatible modifiers

ui/ozone/platform/drm/gpu/gbm_buffer.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/ozone/platform/drm/gpu/gbm_buffer.h"
 
 #include <drm.h>
 #include <fcntl.h>
 #include <gbm.h>
 #include <xf86drm.h>
@@ skipping 65 matching lines @@
 int GbmBuffer::GetOffset(size_t index) const {
   DCHECK_LT(index, planes_.size());
   return planes_[index].offset;
 }
 
 size_t GbmBuffer::GetSize(size_t index) const {
   DCHECK_LT(index, planes_.size());
   return planes_[index].size;
 }
 
-uint64_t GbmBuffer::GetFormatModifier(size_t index) const {
-  DCHECK_LT(index, planes_.size());
-  return planes_[index].modifier;
-}
-
 // TODO(reveman): This should not be needed once crbug.com/597932 is fixed,
 // as the size would be queried directly from the underlying bo.
 gfx::Size GbmBuffer::GetSize() const {
   return size_;
 }
 
 scoped_refptr<GbmBuffer> GbmBuffer::CreateBufferForBO(
     const scoped_refptr<GbmDevice>& gbm,
     gbm_bo* bo,
     uint32_t format,
@@ skipping 60 matching lines @@
     const scoped_refptr<GbmDevice>& gbm,
     uint32_t format,
     const gfx::Size& size,
     uint32_t flags) {
   TRACE_EVENT2("drm", "GbmBuffer::CreateBuffer", "device",
                gbm->device_path().value(), "size", size.ToString());
 
   gbm_bo* bo =
       gbm_bo_create(gbm->device(), size.width(), size.height(), format, flags);
 
-  return CreateBufferForBO(gbm, bo, format, size, flags, 0, 0);
+  return CreateBufferForBO(gbm, bo, format, size, flags,
+                           gbm_bo_get_format_modifier(bo), 0);
 }
 
 // static
 scoped_refptr<GbmBuffer> GbmBuffer::CreateBufferFromFds(
     const scoped_refptr<GbmDevice>& gbm,
     uint32_t format,
     const gfx::Size& size,
     std::vector<base::ScopedFD>&& fds,
     const std::vector<gfx::NativePixmapPlane>& planes) {
   TRACE_EVENT2("drm", "GbmBuffer::CreateBufferFromFD", "device",
@@ skipping 61 matching lines @@
       base::ScopedFD scoped_fd(HANDLE_EINTR(dup(buffer_->GetFd(i))));
       if (!scoped_fd.is_valid()) {
         PLOG(ERROR) << "dup";
         return gfx::NativePixmapHandle();
       }
       handle.fds.emplace_back(
           base::FileDescriptor(scoped_fd.release(), true /* auto_close */));
     }
     handle.planes.emplace_back(buffer_->GetStride(i), buffer_->GetOffset(i),
                                buffer_->GetSize(i),
-                               buffer_->GetFormatModifier(i));
+                               buffer_->GetFormatModifier());
   }
   return handle;
 }
 
 GbmPixmap::~GbmPixmap() {
 }
 
 void* GbmPixmap::GetEGLClientBuffer() const {
   return nullptr;
 }
@@ skipping 12 matching lines @@
 
 int GbmPixmap::GetDmaBufPitch(size_t plane) const {
   return buffer_->GetStride(plane);
 }
 
 int GbmPixmap::GetDmaBufOffset(size_t plane) const {
   return buffer_->GetOffset(plane);
 }
 
 uint64_t GbmPixmap::GetDmaBufModifier(size_t plane) const {
-  return buffer_->GetFormatModifier(plane);
+  return buffer_->GetFormatModifier();
 }
 
 gfx::BufferFormat GbmPixmap::GetBufferFormat() const {
   return ui::GetBufferFormatFromFourCCFormat(buffer_->GetFormat());
 }
 
 gfx::Size GbmPixmap::GetBufferSize() const {
   return buffer_->GetSize();
 }
 
@@ skipping 37 matching lines @@
   DCHECK(!processing_callback_.is_null());
   if (!processing_callback_.Run(this, processed_pixmap_)) {
     LOG(ERROR) << "Failed processing NativePixmap";
     return nullptr;
   }
 
   return processed_pixmap_->buffer();
 }
 
 }  // namespace ui