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 142 matching lines @@
   scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue);
   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) {
-  gfx::GLSurface::Format format = gfx::GLSurface::SURFACE_DEFAULT;  // ARGB8888
-  if (!use_virtualized_gl_context &&
-      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(
     GpuChannel* channel,
     gpu::SyncPointManager* sync_point_manager,
     base::SingleThreadTaskRunner* task_runner,
     GpuCommandBufferStub* share_group,
     const gfx::GLSurfaceHandle& handle,
     gpu::gles2::MailboxManager* mailbox_manager,
     gpu::PreemptionFlag* preempt_by_flag,
@@ skipping 57 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_);
+#if defined(OS_ANDROID)
+  if (attrib_parser.red_size <= 5 &&
+      attrib_parser.green_size <= 6 &&
+      attrib_parser.blue_size <= 5 &&
+      attrib_parser.alpha_size == 0)
+    surface_format_ = gfx::GLSurface::SURFACE_RGB565;
+  gfx::GLSurface* defaultOffscreenSurface =
+      channel_->gpu_channel_manager()->GetDefaultOffscreenSurface();
+  if (surface_format_ != defaultOffscreenSurface->GetFormat())
+    use_virtualized_gl_context_ = false;
+#endif
 
   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_)) {
-      // 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
+      // might not be compatible with this surface.
       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