command_buffer_gles2: Implement EGL default Display as a global object

gpu/gles2_conform_support/egl/context.cc

+// Copyright (c) 2016 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/gles2_conform_support/egl/context.h"
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "gpu/command_buffer/client/gles2_implementation.h"
+#include "gpu/command_buffer/client/gles2_lib.h"
+#include "gpu/command_buffer/client/transfer_buffer.h"
+#include "gpu/command_buffer/common/value_state.h"
+#include "gpu/command_buffer/service/context_group.h"
+#include "gpu/command_buffer/service/mailbox_manager.h"
+#include "gpu/command_buffer/service/memory_tracking.h"
+#include "gpu/command_buffer/service/transfer_buffer_manager.h"
+#include "gpu/command_buffer/service/valuebuffer_manager.h"
+#include "gpu/gles2_conform_support/egl/config.h"
+#include "gpu/gles2_conform_support/egl/display.h"
+#include "gpu/gles2_conform_support/egl/surface.h"
+#include "gpu/gles2_conform_support/egl/thread_state.h"
+
+// The slight complexification in this file comes from following properties:
+// 1) Command buffer connection (context) can not be established without a
+// GLSurface. EGL Context can be created independent of a surface.  This is why
+// the connection is created only during first MakeCurrent.
+// 2) Command buffer MakeCurrent calls need the real gl context and surface be
+// current.
+// 3) Client can change real EGL context behind the scenes and then still expect
+// command buffer MakeCurrent re-set the command buffer context. This is why all
+// MakeCurrent calls must actually reset the real context, even though command
+// buffer current context does not change.
+// 4) EGL context can be destroyed without surface, but command buffer would
+// need the surface to run various cleanups. If context is destroyed
+// surfaceless, the context is marked lost before destruction. This is avoided
+// if possible, since command buffer at the time of writing prints out debug
+// text in this case.
+
+namespace {
+const int32_t kCommandBufferSize = 1024 * 1024;
+const int32_t kTransferBufferSize = 512 * 1024;
+const bool kBindGeneratesResources = true;
+const bool kLoseContextWhenOutOfMemory = false;
+const bool kSupportClientSideArrays = true;
+}
+
+namespace egl {
+Context::Context(Display* display, const Config* config)
+    : display_(display), config_(config), is_current_in_some_thread_(false) {}
+
+Context::~Context() {
+  // We might not have a surface, so we must lose the context.

[piman, 2016/02/23 23:37:16]

If we lose the context, we will leak any resource (textures, buffers, etc) until
the last context in the GLShareGroup is gone. I guess for now we don't support
share groups so we can get away with it, but if we wanted to support them this
would be a problem, especially since this would happen on normal API usage
(eglMakeCurrent(dpy, NULL, NULL, NULL); eglDestroyContext(dpy, context);). Can
you add a TODO to that effect?

One thing we could do is to keep the GLSurface associated with the context when
made not-current, so that we can make current before teardown, if that GLSurface
is not current in another thread (should catch most common cases). That requires
a bunch more tracking, so it's ok to punt for now.

[Kimmo Kinnunen, 2016/02/24 07:33:26]

.. to the extent that there ever will be "normal api usage" of this code..
 
Yeah, I had that code there at some point. It's fairly demotivating to look at.
Same effect one would get with an extra surface of size 0,0 just for destroying
purposes, and that probably is simpler and has one limitation less. It still
looks bad and can not support window surfaces.

I'm slightly dragging my feet to add these TODOs. IMHO to add a TODO, there
should be genuine interest and purpose to remove the TODO at some point.

[piman, 2016/02/24 21:53:45]

It's more a heads-up/documentation thing for something that is not right
(especially when it's not obvious for the code), and some idea about a solution
and/or who knows about it.

+  // Cleanup will execute GL commands otherwise.
+  if (HasService()) {
+    if (!WasServiceContextLost())
+      MarkServiceContextLost();
+    DestroyService();
+  }
+}
+
+void Context::FlushAndSwapBuffers(gfx::GLSurface* current_surface) {
+  DCHECK(HasService() && is_current_in_some_thread_);
+  if (!Flush(current_surface))
+    return;
+  current_surface->SwapBuffers();
+}
+
+bool Context::MakeCurrent(Context* current_context,
+                          gfx::GLSurface* current_surface,
+                          Context* new_context,
+                          gfx::GLSurface* new_surface) {
+  if (!new_context && !current_context) {
+    return true;
+  }
+
+  bool cleanup_old_current_context = false;
+  if (current_context) {
+    if (current_context->Flush(current_surface))
+      cleanup_old_current_context = new_context != current_context;
+  }
+
+  if (new_context) {
+    if (!new_context->IsCompatibleSurface(new_surface))
+      return false;
+
+    if (new_context->HasService()) {
+      if (new_context->WasServiceContextLost())
+        return false;
+      if (new_context != current_context) {
+        // If Flush did not set the current context, set it now. Otherwise
+        // calling into the decoder is not ok.
+        if (!new_context->gl_context_->MakeCurrent(new_surface)) {
+          new_context->MarkServiceContextLost();
+          return false;
+        }
+      }
+      if (new_context != current_context || new_surface != current_surface)
+        new_context->decoder_->SetSurface(new_surface);
+      if (!new_context->decoder_->MakeCurrent()) {
+        new_context->MarkServiceContextLost();
+        return false;
+      }
+    } else {
+      if (!new_context->CreateService(new_surface)) {
+        return false;
+      }
+    }
+  }
+
+  // The current_surface will be released when MakeCurrent succeeds.
+  // Cleanup in this case only.
+  if (cleanup_old_current_context) {
+    if (current_context->HasOneRef() && current_surface != new_surface) {

[piman, 2016/02/23 23:37:16]

I'm somewhat uncomfortable with HasOneRef(), because while this may work now,
any added scoped_refptr (e.g. see discussion on chromium-dev about preferred
style for passing refcounts to functions) may break this, unless that code also
manages releasing the last reference with similar logic.

Instead, I think we can have Display::DestroyContext mark the context as
destroyed (adding a bool to Context), and cleanup here if that bit is set -
regardless of refcount.

[Kimmo Kinnunen, 2016/02/24 07:33:26]

Done.

+      current_context->gl_context_->MakeCurrent(current_surface);
+      // If we are releasing the context and we have one ref, it means that the
+      // ref will be lost and the object will be destroyed.  Destroy the service
+      // explicitly here, so that cleanup can happen and client GL
+      // implementation does not print errors.
+      current_context->DestroyService();
+    } else {
+      current_context->decoder_->ReleaseSurface();
+    }
+  }
+
+  return true;
+}
+
+bool Context::ValidateAttributeList(const EGLint* attrib_list) {
+  if (attrib_list) {
+    for (int i = 0; attrib_list[i] != EGL_NONE; attrib_list += 2) {
+      switch (attrib_list[i]) {
+        case EGL_CONTEXT_CLIENT_VERSION:
+          break;
+        default:
+          return false;
+      }
+    }
+  }
+  return true;
+}
+
+gpu::Capabilities Context::GetCapabilities() {
+  return decoder_->GetCapabilities();
+}
+
+int32_t Context::CreateImage(ClientBuffer buffer,
+                             size_t width,
+                             size_t height,
+                             unsigned internalformat) {
+  NOTIMPLEMENTED();
+  return -1;
+}
+
+void Context::DestroyImage(int32_t id) {
+  NOTIMPLEMENTED();
+}
+
+int32_t Context::CreateGpuMemoryBufferImage(size_t width,
+                                            size_t height,
+                                            unsigned internalformat,
+                                            unsigned usage) {
+  NOTIMPLEMENTED();
+  return -1;
+}
+
+void Context::SignalQuery(uint32_t query, const base::Closure& callback) {
+  NOTIMPLEMENTED();
+}
+
+void Context::SetLock(base::Lock*) {
+  NOTIMPLEMENTED();
+}
+
+bool Context::IsGpuChannelLost() {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+void Context::EnsureWorkVisible() {
+  // This is only relevant for out-of-process command buffers.
+}
+
+gpu::CommandBufferNamespace Context::GetNamespaceID() const {
+  return gpu::CommandBufferNamespace::IN_PROCESS;
+}
+
+gpu::CommandBufferId Context::GetCommandBufferID() const {
+  return gpu::CommandBufferId();
+}
+
+int32_t Context::GetExtraCommandBufferData() const {
+  return 0;
+}
+
+uint64_t Context::GenerateFenceSyncRelease() {
+  return display_->GenerateFenceSyncRelease();
+}
+
+bool Context::IsFenceSyncRelease(uint64_t release) {
+  return display_->IsFenceSyncRelease(release);
+}
+
+bool Context::IsFenceSyncFlushed(uint64_t release) {
+  return display_->IsFenceSyncFlushed(release);
+}
+
+bool Context::IsFenceSyncFlushReceived(uint64_t release) {
+  return display_->IsFenceSyncFlushReceived(release);
+}
+
+void Context::SignalSyncToken(const gpu::SyncToken& sync_token,
+                              const base::Closure& callback) {
+  NOTIMPLEMENTED();
+}
+
+bool Context::CanWaitUnverifiedSyncToken(const gpu::SyncToken* sync_token) {
+  return false;
+}
+
+void Context::ApplyCurrentContext(gfx::GLSurface* current_surface) {
+  DCHECK(HasService());
+  // The current_surface will be the same as
+  // the surface of the decoder. We can not DCHECK as there is
+  // no accessor.
+  if (!WasServiceContextLost()) {
+    if (!gl_context_->MakeCurrent(current_surface))
+      MarkServiceContextLost();
+  }
+  gles2::SetGLContext(client_gl_context_.get());
+}
+
+void Context::ApplyContextReleased() {
+  gles2::SetGLContext(nullptr);
+}
+
+bool Context::CreateService(gfx::GLSurface* gl_surface) {
+  scoped_refptr<gpu::TransferBufferManager> transfer_buffer_manager(
+      new gpu::TransferBufferManager(nullptr));
+  transfer_buffer_manager->Initialize();
+
+  scoped_ptr<gpu::CommandBufferService> command_buffer(
+      new gpu::CommandBufferService(transfer_buffer_manager.get()));
+  if (!command_buffer->Initialize())
+    return false;
+
+  scoped_refptr<gpu::gles2::ContextGroup> group(new gpu::gles2::ContextGroup(
+      NULL, NULL, new gpu::gles2::ShaderTranslatorCache,
+      new gpu::gles2::FramebufferCompletenessCache, NULL, NULL, NULL, true));
+
+  scoped_ptr<gpu::gles2::GLES2Decoder> decoder(
+      gpu::gles2::GLES2Decoder::Create(group.get()));
+  if (!decoder.get())
+    return false;
+
+  scoped_ptr<gpu::GpuScheduler> gpu_scheduler(new gpu::GpuScheduler(
+      command_buffer.get(), decoder.get(), decoder.get()));
+
+  decoder->set_engine(gpu_scheduler.get());
+
+  scoped_refptr<gfx::GLContext> gl_context(gfx::GLContext::CreateGLContext(
+      nullptr, gl_surface, gfx::PreferDiscreteGpu));
+  if (!gl_context)
+    return false;
+
+  gl_context->MakeCurrent(gl_surface);
+
+  gpu::gles2::ContextCreationAttribHelper helper;
+  config_->GetAttrib(EGL_ALPHA_SIZE, &helper.alpha_size);
+  config_->GetAttrib(EGL_BLUE_SIZE, &helper.blue_size);
+  config_->GetAttrib(EGL_GREEN_SIZE, &helper.green_size);
+  config_->GetAttrib(EGL_RED_SIZE, &helper.red_size);
+  config_->GetAttrib(EGL_DEPTH_SIZE, &helper.depth_size);
+  config_->GetAttrib(EGL_STENCIL_SIZE, &helper.stencil_size);
+  config_->GetAttrib(EGL_SAMPLES, &helper.samples);
+  config_->GetAttrib(EGL_SAMPLE_BUFFERS, &helper.sample_buffers);
+
+  helper.buffer_preserved = false;
+  helper.bind_generates_resource = kBindGeneratesResources;
+  helper.fail_if_major_perf_caveat = false;
+  helper.lose_context_when_out_of_memory = kLoseContextWhenOutOfMemory;
+  helper.context_type = gpu::gles2::CONTEXT_TYPE_OPENGLES2;
+  std::vector<int32_t> attribs;
+  helper.Serialize(&attribs);
+
+  if (!decoder->Initialize(gl_surface, gl_context.get(),
+                           gl_surface->IsOffscreen(), gl_surface->GetSize(),
+                           gpu::gles2::DisallowedFeatures(), attribs)) {
+    return false;
+  }
+
+  command_buffer->SetPutOffsetChangeCallback(base::Bind(
+      &gpu::GpuScheduler::PutChanged, base::Unretained(gpu_scheduler.get())));
+  command_buffer->SetGetBufferChangeCallback(base::Bind(
+      &gpu::GpuScheduler::SetGetBuffer, base::Unretained(gpu_scheduler.get())));
+
+  scoped_ptr<gpu::gles2::GLES2CmdHelper> gles2_cmd_helper(
+      new gpu::gles2::GLES2CmdHelper(command_buffer.get()));
+  if (!gles2_cmd_helper->Initialize(kCommandBufferSize)) {
+    decoder->Destroy(true);
+    return false;
+  }
+
+  scoped_ptr<gpu::TransferBuffer> transfer_buffer(
+      new gpu::TransferBuffer(gles2_cmd_helper.get()));
+
+  gles2_cmd_helper_.reset(gles2_cmd_helper.release());
+  transfer_buffer_.reset(transfer_buffer.release());
+  command_buffer_.reset(command_buffer.release());
+  gpu_scheduler_.reset(gpu_scheduler.release());
+  decoder_.reset(decoder.release());
+  gl_context_ = gl_context.get();
+
+  scoped_ptr<gpu::gles2::GLES2Implementation> context(
+      new gpu::gles2::GLES2Implementation(
+          gles2_cmd_helper_.get(), nullptr, transfer_buffer_.get(),
+          kBindGeneratesResources, kLoseContextWhenOutOfMemory,
+          kSupportClientSideArrays, this));
+
+  if (!context->Initialize(kTransferBufferSize, kTransferBufferSize / 2,
+                           kTransferBufferSize * 2,
+                           gpu::gles2::GLES2Implementation::kNoLimit)) {
+    DestroyService();
+    return false;
+  }
+
+  context->EnableFeatureCHROMIUM("pepper3d_allow_buffers_on_multiple_targets");
+  context->EnableFeatureCHROMIUM("pepper3d_support_fixed_attribs");
+  client_gl_context_.reset(context.release());
+  return true;
+}
+
+void Context::DestroyService() {
+  DCHECK(HasService());
+  bool have_context = !WasServiceContextLost();
+  // The client gl interface might still be set to current global
+  // interface. This will be cleaned up in ApplyContextReleased
+  // with AutoCurrentContextRestore.
+  client_gl_context_.reset();
+  gl_context_ = nullptr;
+
+  transfer_buffer_.reset();
+  gpu_scheduler_.reset();
+  if (decoder_)
+    decoder_->Destroy(have_context);
+  gles2_cmd_helper_.reset();
+  command_buffer_.reset();
+}
+
+bool Context::HasService() const {
+  return decoder_ != nullptr;
+}
+
+void Context::MarkServiceContextLost() {
+  decoder_->MarkContextLost(gpu::error::kMakeCurrentFailed);
+}
+
+bool Context::WasServiceContextLost() const {
+  return decoder_->WasContextLost();
+}
+
+bool Context::IsCompatibleSurface(gfx::GLSurface* gl_surface) {
+  EGLint value = EGL_NONE;
+  config_->GetAttrib(EGL_SURFACE_TYPE, &value);
+  bool config_is_offscreen = (value & EGL_PBUFFER_BIT) != 0;
+  return gl_surface->IsOffscreen() == config_is_offscreen;
+}
+
+bool Context::Flush(gfx::GLSurface* gl_surface) {
+  if (WasServiceContextLost())
+    return false;
+  if (!gl_context_->MakeCurrent(gl_surface)) {
+    MarkServiceContextLost();
+    return false;
+  }
+  client_gl_context_->Flush();
+  return true;
+}
+
+}  // namespace egl