exo: Directly create GpuMemoryBufferImpl when a handle is available.

components/exo/shared_memory.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 "components/exo/shared_memory.h"
 
 #include <GLES2/gl2extchromium.h>
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
 #include "components/exo/buffer.h"
-#include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
+#include "gpu/ipc/client/gpu_memory_buffer_impl.h"
 #include "third_party/khronos/GLES2/gl2.h"
-#include "ui/aura/env.h"
 #include "ui/compositor/compositor.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 
 namespace exo {
 namespace {
 
 bool IsSupportedFormat(gfx::BufferFormat format) {
   return format == gfx::BufferFormat::RGBX_8888 ||
          format == gfx::BufferFormat::RGBA_8888 ||
          format == gfx::BufferFormat::BGRX_8888 ||
          format == gfx::BufferFormat::BGRA_8888;
 }
 
+void DoNothing(const gpu::SyncToken& sync) {}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // SharedMemory, public:
 
 SharedMemory::SharedMemory(const base::SharedMemoryHandle& handle)
     : shared_memory_(handle, true /* read-only */) {}
 
 SharedMemory::~SharedMemory() {}
 
@@ skipping 18 matching lines @@
                   << stride;
     return nullptr;
   }
 
   gfx::GpuMemoryBufferHandle handle;
   handle.type = gfx::SHARED_MEMORY_BUFFER;
   handle.handle = base::SharedMemory::DuplicateHandle(shared_memory_.handle());
   handle.offset = offset;
   handle.stride = stride;
 
-  std::unique_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer =
-      aura::Env::GetInstance()
-          ->context_factory()
-          ->GetGpuMemoryBufferManager()
-          ->CreateGpuMemoryBufferFromHandle(handle, size, format);
+  auto gpu_memory_buffer = gpu::GpuMemoryBufferImpl::CreateFromHandle(

[reveman, 2016/12/13 21:30:53]

ditto. avoid auto and use gpu::GpuMemoryBufferImplSharedMemory directly

[sadrul, 2016/12/14 01:41:30]

Done.

+      handle, size, format, gfx::BufferUsage::GPU_READ, base::Bind(&DoNothing));
   if (!gpu_memory_buffer) {
     LOG(ERROR) << "Failed to create GpuMemoryBuffer from handle";
     return nullptr;
   }
 
   // Zero-copy doesn't provide a benefit in the case of shared memory as an
   // implicit copy is required when trying to use these buffers as zero-copy
   // buffers. Making the copy explicit allows the buffer to be reused earlier.
   bool use_zero_copy = false;
 
   return base::MakeUnique<Buffer>(
       std::move(gpu_memory_buffer), GL_TEXTURE_2D,
       // COMMANDS_ISSUED queries are sufficient for shared memory
       // buffers as binding to texture is implemented using a call to
       // glTexImage2D and the buffer can be reused as soon as that
       // command has been issued.
       GL_COMMANDS_ISSUED_CHROMIUM, use_zero_copy,
       false /* is_overlay_candidate */);
 }
 
 }  // namespace exo