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 129 matching lines @@
   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) {

[no sievers, 2016/02/17 23:38:01]

nit: this argument is unused now

[Jinsuk Kim, 2016/02/18 02:57:24]

Done.

   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();
+
+  // On-screen 16-bit surfaces on low-end device won't use virtualized context.

[no sievers, 2016/02/17 23:38:01]

You mean 32-bit surfaces, right?

[Jinsuk Kim, 2016/02/18 02:57:24]

My bad.. removed the comment as this part is being reverted.

+  if (handle_.is_null() ||
+      !base::SysInfo::IsLowEndDevice() ||

[no sievers, 2016/02/17 23:38:01]

You could actually generalize this and just say that if the default offscreen
surface's format doesn't match the requested format (and the requested surface
is onscreen), then don't allow virtualization.

Or even more generally: if the share context's config is not compatible with the
requested config here.

[Jinsuk Kim, 2016/02/18 02:57:24]

Done.

+      surface_format_ == gfx::GLSurface::SURFACE_RGB565) {
+    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.
       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