Android: Use virtualized context only for those with compatible config

content/common/gpu/gpu_command_buffer_stub.cc

 // Copyright (c) 2012 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 "content/common/gpu/gpu_command_buffer_stub.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 146 matching lines @@
 }
 
 uint64_t GetCommandBufferID(int channel_id, int32_t route_id) {
   return (static_cast<uint64_t>(channel_id) << 32) | route_id;
 }
 
 gfx::GLSurface::Format GetSurfaceFormatFromAttribute(
     const gpu::gles2::ContextCreationAttribHelper& attrib,
     bool use_virtualized_gl_context) {
   gfx::GLSurface::Format format = gfx::GLSurface::SURFACE_DEFAULT;  // ARGB8888
-  if (!use_virtualized_gl_context &&
-      attrib.red_size <= 5 &&
+  if (attrib.red_size <= 5 &&
       attrib.green_size <= 6 &&
       attrib.blue_size <= 5 &&
       attrib.alpha_size == 0) {
     format = gfx::GLSurface::SURFACE_RGB565;
   }
   return format;
 }
 }  // namespace
 
 GpuCommandBufferStub::GpuCommandBufferStub(
@@ skipping 375 matching lines @@
     surface_ = manager->GetDefaultOffscreenSurface();
   }
 
   if (!surface_.get()) {
     DLOG(ERROR) << "Failed to create surface.";
     OnInitializeFailed(reply_message);
     return;
   }
 
   scoped_refptr<gfx::GLContext> context;
-  if (use_virtualized_gl_context_ && channel_->share_group()) {
-    context = channel_->share_group()->GetSharedContext();
+  gfx::GLShareGroup* share_group = channel_->share_group();
+  if (use_virtualized_gl_context_ && share_group) {

[no sievers, 2016/02/17 00:56:26]

Is it simpler to just treat |is_onscreen && is_lowend && is_32bit_requested| as
a non-virtual context?

And then we don't have to track multiple share contexts and we don't need
UpdateSharedContext().

I think Mac at least used to work in a similar way that it only uses context
virtualization for some of the contexts (onscreen I think).

But we do need to force all offscreen contexts into 16bit then also on low-end,
which is PbufferGLSurfaceEGL::Initialize(). We could just default the config to
16bit on lowend.

wdyt?

[Jinsuk Kim, 2016/02/17 07:23:32]

Good to know that virtualization can be done for some of the contexts (was not
aware of it). Then the change can be much simpler. Done.

Note that multiple shared contexts in shared group has a benefit in that it
saves you from creating real context every time the request comes in. It also
works as a context cache reusing the previously created real context for new
requests. 


The default config for low-end device is set to 16bit. Please see
CreateOffscreenGLSurface(size) in gl_surface.h.

+    context = share_group->GetSharedContext();
     if (!context.get()) {
-      context = gfx::GLContext::CreateGLContext(
-          channel_->share_group(),
-          channel_->gpu_channel_manager()->GetDefaultOffscreenSurface(),
-          gpu_preference_);
+      share_group->UpdateActiveSharedContext(surface_.get(), gpu_preference_);
+      context = share_group->GetSharedContext();
       if (!context.get()) {
-        DLOG(ERROR) << "Failed to create shared context for virtualization.";
         OnInitializeFailed(reply_message);
         return;
       }
-      channel_->share_group()->SetSharedContext(context.get());
     }
     // This should be a non-virtual GL context.
     DCHECK(context->GetHandle());
     context = new gpu::GLContextVirtual(
-        channel_->share_group(), context.get(), decoder_->AsWeakPtr());
+        share_group, context.get(), decoder_->AsWeakPtr());
     if (!context->Initialize(surface_.get(), gpu_preference_)) {
-      // TODO(sievers): The real context created above for the default
-      // offscreen surface might not be compatible with this surface.
-      // Need to adjust at least GLX to be able to create the initial context
-      // with a config that is compatible with onscreen and offscreen surfaces.
-      context = NULL;
-
-      DLOG(ERROR) << "Failed to initialize virtual GL context.";
-      OnInitializeFailed(reply_message);
-      return;
+      // Context with incompatible configuration was attempted to be made
+      // current. Update the shared context to a compatible one and init again.
+      share_group->UpdateActiveSharedContext(surface_.get(), gpu_preference_);
+      context->UpdateSharedContext(share_group->GetSharedContext());
+      if (!context->Initialize(surface_.get(), gpu_preference_)) {
+        DLOG(ERROR) << "Failed to initialize virtual GL context.";
+        OnInitializeFailed(reply_message);
+        return;
+      }
     }
   }
   if (!context.get()) {
     context = gfx::GLContext::CreateGLContext(
-        channel_->share_group(), surface_.get(), gpu_preference_);
+        share_group, surface_.get(), gpu_preference_);
   }
   if (!context.get()) {
     DLOG(ERROR) << "Failed to create context.";
     OnInitializeFailed(reply_message);
     return;
   }
 
   if (!context->MakeCurrent(surface_.get())) {
     LOG(ERROR) << "Failed to make context current.";
     OnInitializeFailed(reply_message);
@@ skipping 571 matching lines @@
                                                     result));
 }
 
 void GpuCommandBufferStub::SendUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
                                                      interval));
 }
 
 }  // namespace content