gpu/blink/webgraphicscontext3d_in_process_command_buffer_impl.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "gpu/blink/webgraphicscontext3d_in_process_command_buffer_impl.h"
   6
   7 #include <GLES2/gl2.h>
   8 #ifndef GL_GLEXT_PROTOTYPES
   9 #define GL_GLEXT_PROTOTYPES 1
  10 #endif
  11 #include <GLES2/gl2ext.h>
  12 #include <GLES2/gl2extchromium.h>
  13
  14 #include <string>
  15
  16 #include "base/atomicops.h"
  17 #include "base/bind.h"
  18 #include "base/bind_helpers.h"
  19 #include "base/callback.h"
  20 #include "base/logging.h"
  21 #include "gpu/command_buffer/client/gles2_implementation.h"
  22 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
  23 #include "gpu/skia_bindings/gl_bindings_skia_cmd_buffer.h"
  24 #include "ui/gfx/geometry/size.h"
  25 #include "ui/gl/gl_implementation.h"
  26
  27 using blink::WGC3Denum;
  28 using gpu::gles2::GLES2Implementation;
  29 using gpu::GLInProcessContext;
  30
  31 namespace gpu_blink {
  32
  33 // static
  34 scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl>
  35 WebGraphicsContext3DInProcessCommandBufferImpl::CreateViewContext(
  36     const blink::WebGraphicsContext3D::Attributes& attributes,
  37     bool lose_context_when_out_of_memory,
  38     gfx::AcceleratedWidget window) {
  39   DCHECK_NE(gfx::GetGLImplementation(), gfx::kGLImplementationNone);
  40   bool is_offscreen = false;
  41   return make_scoped_ptr(new WebGraphicsContext3DInProcessCommandBufferImpl(
  42       scoped_ptr< ::gpu::GLInProcessContext>(),
  43       attributes,
  44       lose_context_when_out_of_memory,
  45       is_offscreen,
  46       window));
  47 }
  48
  49 // static
  50 scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl>
  51 WebGraphicsContext3DInProcessCommandBufferImpl::CreateOffscreenContext(
  52     const blink::WebGraphicsContext3D::Attributes& attributes,
  53     bool lose_context_when_out_of_memory) {
  54   bool is_offscreen = true;
  55   return make_scoped_ptr(new WebGraphicsContext3DInProcessCommandBufferImpl(
  56       scoped_ptr< ::gpu::GLInProcessContext>(),
  57       attributes,
  58       lose_context_when_out_of_memory,
  59       is_offscreen,
  60       gfx::kNullAcceleratedWidget));
  61 }
  62
  63 scoped_ptr<WebGraphicsContext3DInProcessCommandBufferImpl>
  64 WebGraphicsContext3DInProcessCommandBufferImpl::WrapContext(
  65     scoped_ptr< ::gpu::GLInProcessContext> context,
  66     const blink::WebGraphicsContext3D::Attributes& attributes) {
  67   bool lose_context_when_out_of_memory = false;  // Not used.
  68   bool is_offscreen = true;                      // Not used.
  69   return make_scoped_ptr(new WebGraphicsContext3DInProcessCommandBufferImpl(
  70       context.Pass(),
  71       attributes,
  72       lose_context_when_out_of_memory,
  73       is_offscreen,
  74       gfx::kNullAcceleratedWidget /* window. Not used. */));
  75 }
  76
  77 WebGraphicsContext3DInProcessCommandBufferImpl::
  78     WebGraphicsContext3DInProcessCommandBufferImpl(
  79         scoped_ptr< ::gpu::GLInProcessContext> context,
  80         const blink::WebGraphicsContext3D::Attributes& attributes,
  81         bool lose_context_when_out_of_memory,
  82         bool is_offscreen,
  83         gfx::AcceleratedWidget window)
  84     : share_resources_(attributes.shareResources),
  85       webgl_context_(attributes.webGL),
  86       is_offscreen_(is_offscreen),
  87       window_(window),
  88       context_(context.Pass()) {
  89   ConvertAttributes(attributes, &attribs_);
  90   attribs_.lose_context_when_out_of_memory = lose_context_when_out_of_memory;
  91 }
  92
  93 WebGraphicsContext3DInProcessCommandBufferImpl::
  94     ~WebGraphicsContext3DInProcessCommandBufferImpl() {
  95 }
  96
  97 size_t WebGraphicsContext3DInProcessCommandBufferImpl::GetMappedMemoryLimit() {
  98   return context_->GetMappedMemoryLimit();
  99 }
 100
 101 bool WebGraphicsContext3DInProcessCommandBufferImpl::MaybeInitializeGL() {
 102   if (initialized_)
 103     return true;
 104
 105   if (initialize_failed_)
 106     return false;
 107
 108   if (!context_) {
 109     // TODO(kbr): More work will be needed in this implementation to
 110     // properly support GPU switching. Like in the out-of-process
 111     // command buffer implementation, all previously created contexts
 112     // will need to be lost either when the first context requesting the
 113     // discrete GPU is created, or the last one is destroyed.
 114     gfx::GpuPreference gpu_preference = gfx::PreferDiscreteGpu;
 115     context_.reset(GLInProcessContext::Create(
 116         NULL, /* service */
 117         NULL, /* surface */
 118         is_offscreen_,
 119         window_,
 120         gfx::Size(1, 1),
 121         NULL, /* share_context */
 122         share_resources_,
 123         attribs_,
 124         gpu_preference,
 125         ::gpu::GLInProcessContextSharedMemoryLimits(),
 126         nullptr,
 127         nullptr));
 128   }
 129
 130   if (context_) {
 131     base::Closure context_lost_callback = base::Bind(
 132         &WebGraphicsContext3DInProcessCommandBufferImpl::OnContextLost,
 133         base::Unretained(this));
 134     context_->SetContextLostCallback(context_lost_callback);
 135   } else {
 136     initialize_failed_ = true;
 137     return false;
 138   }
 139
 140   real_gl_ = context_->GetImplementation();
 141   setGLInterface(real_gl_);
 142
 143   if (real_gl_ && webgl_context_)
 144     real_gl_->EnableFeatureCHROMIUM("webgl_enable_glsl_webgl_validation");
 145
 146   initialized_ = true;
 147   return true;
 148 }
 149
 150 bool
 151 WebGraphicsContext3DInProcessCommandBufferImpl::InitializeOnCurrentThread() {
 152   if (!MaybeInitializeGL())
 153     return false;
 154   return context_ && !isContextLost();
 155 }
 156
 157 void WebGraphicsContext3DInProcessCommandBufferImpl::SetLock(base::Lock* lock) {
 158   context_->SetLock(lock);
 159 }
 160
 161 bool WebGraphicsContext3DInProcessCommandBufferImpl::isContextLost() {
 162   return context_lost_reason_ != GL_NO_ERROR;
 163 }
 164
 165 WGC3Denum WebGraphicsContext3DInProcessCommandBufferImpl::
 166     getGraphicsResetStatusARB() {
 167   return context_lost_reason_;
 168 }
 169
 170 ::gpu::ContextSupport*
 171 WebGraphicsContext3DInProcessCommandBufferImpl::GetContextSupport() {
 172   return real_gl_;
 173 }
 174
 175 void WebGraphicsContext3DInProcessCommandBufferImpl::OnContextLost() {
 176   // TODO(kbr): improve the precision here.
 177   context_lost_reason_ = GL_UNKNOWN_CONTEXT_RESET_ARB;
 178   if (context_lost_callback_) {
 179     context_lost_callback_->onContextLost();
 180   }
 181 }
 182
 183 }  // namespace gpu_blink