Scan-out capable buffers (aka ui::NativePixmap) for Mus

components/mus/gles2/command_buffer_driver.cc

 // Copyright 2013 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 "components/mus/gles2/command_buffer_driver.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 17 matching lines @@
 #include "gpu/command_buffer/service/valuebuffer_manager.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/platform_handle/platform_handle_functions.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gfx/vsync_provider.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image_shared_memory.h"
 #include "ui/gl/gl_surface.h"
 
+#if defined(USE_OZONE)
+#include "ui/gl/gl_image_ozone_native_pixmap.h"
+#endif
+
 namespace mus {
 
 namespace {
 
 // The first time polling a fence, delay some extra time to allow other
 // stubs to process some work, or else the timing of the fences could
 // allow a pattern of alternating fast and slow frames to occur.
 const int64_t kHandleMoreWorkPeriodMs = 2;
 const int64_t kHandleMoreWorkPeriodBusyMs = 1;
 
@@ skipping 29 matching lines @@
     mojo::ScopedSharedBufferHandle shared_state,
     mojo::Array<int32_t> attribs) {
   DCHECK(CalledOnValidThread());
   gpu::gles2::ContextCreationAttribHelper attrib_helper;
   if (!attrib_helper.Parse(attribs.storage()))
     return false;
 
   const bool offscreen = widget_ == gfx::kNullAcceleratedWidget;
   static scoped_refptr<gfx::GLSurface> underlying_surface;
   if (offscreen) {
-    surface_ = gfx::GLSurface::CreateOffscreenGLSurface(gfx::Size(1, 1));
+    surface_ = gfx::GLSurface::CreateOffscreenGLSurface(gfx::Size(0, 0));
   } else {
+#if defined(USE_OZONE)
+    scoped_refptr<gfx::GLSurface> underlying_surface =
+        gfx::GLSurface::CreateSurfacelessViewGLSurface(widget_);
+    if (!underlying_surface)
+      underlying_surface = gfx::GLSurface::CreateViewGLSurface(widget_);
+#else
+    scoped_refptr<gfx::GLSurface> underlying_surface =
+        gfx::GLSurface::CreateViewGLSurface(widget_);
+#endif
     scoped_refptr<GLSurfaceAdapterMus> surface_adapter =
-        new GLSurfaceAdapterMus(gfx::GLSurface::CreateViewGLSurface(widget_));
+        new GLSurfaceAdapterMus(underlying_surface);
     surface_adapter->SetGpuCompletedSwapBuffersCallback(
         base::Bind(&CommandBufferDriver::OnGpuCompletedSwapBuffers,
                    weak_factory_.GetWeakPtr()));
     surface_ = surface_adapter;
 
     gfx::VSyncProvider* vsync_provider =
         surface_ ? surface_->GetVSyncProvider() : nullptr;
     if (vsync_provider) {
       vsync_provider->GetVSyncParameters(
           base::Bind(&CommandBufferDriver::OnUpdateVSyncParameters,
@@ skipping 164 matching lines @@
   if (!image->Initialize(
           handle, gfx::GpuMemoryBufferId(id), gpu_format, 0,
           gfx::RowSizeForBufferFormat(gfx_size.width(), gpu_format, 0))) {
     NOTREACHED();
     return;
   }
 
   image_manager->AddImage(image.get(), id);
 }
 
+// TODO(rjkroege): It is conceivable that this code belongs in
+// ozone_gpu_memory_buffer.cc
+void CommandBufferDriver::CreateImageNativeOzone(int32_t id,
+                                                 int32_t type,
+                                                 gfx::Size size,
+                                                 gfx::BufferFormat format,
+                                                 uint32_t internal_format,
+                                                 ui::NativePixmap* pixmap) {
+#if defined(USE_OZONE)
+  gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager();
+  if (image_manager->LookupImage(id)) {
+    LOG(ERROR) << "Image already exists with same ID.";
+    return;
+  }
+
+  scoped_refptr<gfx::GLImageOzoneNativePixmap> image =
+      new gfx::GLImageOzoneNativePixmap(size, internal_format);
+  if (!image->Initialize(pixmap, format)) {
+    NOTREACHED();
+    return;
+  }
+
+  image_manager->AddImage(image.get(), id);
+#endif
+}
+
 void CommandBufferDriver::DestroyImage(int32_t id) {
   DCHECK(CalledOnValidThread());
   gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager();
   if (!image_manager->LookupImage(id)) {
     LOG(ERROR) << "Image with ID doesn't exist.";
     return;
   }
   if (!MakeCurrent())
     return;
   image_manager->RemoveImage(id);
 }
 
 bool CommandBufferDriver::IsScheduled() const {
   DCHECK(CalledOnValidThread());
+  DCHECK(executor_);
   return executor_->scheduled();
 }
 
 bool CommandBufferDriver::HasUnprocessedCommands() const {
   DCHECK(CalledOnValidThread());
   if (command_buffer_) {
     gpu::CommandBuffer::State state = GetLastState();
     return command_buffer_->GetPutOffset() != state.get_offset &&
         !gpu::error::IsError(state.error);
   }
@@ skipping 205 matching lines @@
 }
 
 void CommandBufferDriver::OnGpuCompletedSwapBuffers(gfx::SwapResult result) {
   DCHECK(CalledOnValidThread());
   if (client_) {
     client_->OnGpuCompletedSwapBuffers(result);
   }
 }
 
 }  // namespace mus