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"
 #include "base/command_line.h"
 #include "base/hash.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/memory/shared_memory.h"
+#include "base/sys_info.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/gpu_channel_manager.h"
 #include "content/common/gpu/gpu_memory_manager.h"
 #include "content/common/gpu/gpu_memory_tracking.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/gpu/gpu_watchdog.h"
 #include "content/common/gpu/image_transport_surface.h"
@@ skipping 128 matching lines @@
   res->SetInteger("renderer_pid", channel->GetClientPID());
   res->SetDouble("used_bytes", channel->GetMemoryUsage());
   return new DevToolsChannelData(res.release());
 }
 
 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) {
+    const gpu::gles2::ContextCreationAttribHelper& attrib) {
   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 64 matching lines @@
     use_virtualized_gl_context_ = true;
 #endif
 
   use_virtualized_gl_context_ |=
       context_group_->feature_info()->workarounds().use_virtualized_gl_contexts;
 
   // MailboxManagerSync synchronization correctness currently depends on having
   // only a single context. See crbug.com/510243 for details.
   use_virtualized_gl_context_ |= mailbox_manager->UsesSync();
 
-  surface_format_ = GetSurfaceFormatFromAttribute(attrib_parser,
-                                                  use_virtualized_gl_context_);
+  surface_format_ = GetSurfaceFormatFromAttribute(attrib_parser);
 
   if (offscreen && initial_size_.IsEmpty()) {
     // If we're an offscreen surface with zero width and/or height, set to a
     // non-zero size so that we have a complete framebuffer for operations like
     // glClear.
     initial_size_ = gfx::Size(1, 1);
   }
 }
 
 GpuCommandBufferStub::~GpuCommandBufferStub() {
@@ skipping 289 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) {
+    context = share_group->GetSharedContext();
     if (!context.get()) {
       context = gfx::GLContext::CreateGLContext(
           channel_->share_group(),
           channel_->gpu_channel_manager()->GetDefaultOffscreenSurface(),
           gpu_preference_);
       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_)) {

[no sievers, 2016/02/18 20:19:45]

Unfortunately Initialize() is not reliable to determine if the context is
compatible, because of the IsCurrent(compatible_surface) check in there and
GLContextVirtual::IsCurrent() lying about this for offscreen surfaces, and
therefore depending on current state (in other words it might succeed now but
still fail MakeCurrent() at a later time).

How about simply toggling |use_virtualized_gl_context_| off in the constructor
above if
channel_->gpu_channel_manager()->GetDefaultOffscreenSurface()->GetFormat()
doesn't match |surface_format_|?

[Jinsuk Kim, 2016/02/19 01:04:40]

Got it. I guarded it with #if for it to take effect only on android. Let me know
if it looks okay.

-      // 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.
+      // The real context created above for the default offscreen surface
+      // is not compatible with this surface. Do not use a virtualized context.
+      // in this case.
       context = NULL;
-
-      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