Android: Use virtualized context only for those with compatible config

ui/gl/gl_share_group.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 "ui/gl/gl_share_group.h"
 
 #include "base/logging.h"
 #include "build/build_config.h"
 #include "ui/gl/gl_context.h"
 
 namespace gfx {
 
 GLShareGroup::GLShareGroup()
-    : shared_context_(NULL)
+    : shared_contexts_(
+          make_scoped_ptr(new std::map<GLSurface::Format,
+                                       scoped_refptr<GLContext>>())),
+      active_context_(nullptr),
+      format_(GLSurface::GetDefaultFormat())
 #if defined(OS_MACOSX)
     , renderer_id_(-1)
 #endif
     {
 }
 
 void GLShareGroup::AddContext(GLContext* context) {
   contexts_.insert(context);
 }
 
 void GLShareGroup::RemoveContext(GLContext* context) {
   contexts_.erase(context);
-  if (shared_context_ == context)
-    shared_context_ = NULL;
 }
 
 void* GLShareGroup::GetHandle() {
   GLContext* context = GetContext();
   if (context)
     return context->GetHandle();
 
   return NULL;
 }
 
 GLContext* GLShareGroup::GetContext() {
-  for (ContextSet::iterator it = contexts_.begin();
-       it != contexts_.end();
-       ++it) {
-    if ((*it)->GetHandle())
-      return *it;
+  for (auto context : contexts_) {
+    if (context->GetFormat() == format_ && context->GetHandle())
+      return context;
   }
 
   return NULL;
 }
 
-void GLShareGroup::SetSharedContext(GLContext* context) {
-  DCHECK(contexts_.find(context) != contexts_.end());
-  shared_context_ = context;
+void GLShareGroup::UpdateActiveSharedContext(GLSurface* surface,
+                                             GpuPreference preference) {
+  GLSurface::Format format = surface->GetFormat();
+  scoped_refptr<GLContext> context;
+  auto it = shared_contexts_->find(format);
+  if (it == shared_contexts_->end()) {
+    // The shared context with the matched config not found. Create a new one.
+    context = GLContext::CreateGLContext(this, surface, preference);
+    if (context.get()) {
+      shared_contexts_->insert({format, context});
+    } else {
+      LOG(ERROR) << "Failed to create GLContext.";
+      return;
+    }
+  } else {
+    context = it->second;
+  }
+  active_context_ = context.get();
 }
 
 GLContext* GLShareGroup::GetSharedContext() {
-  return shared_context_;
+  return active_context_;
 }
 
 #if defined(OS_MACOSX)
 void GLShareGroup::SetRendererID(int renderer_id) {
   renderer_id_ = renderer_id;
 }
 
 int GLShareGroup::GetRendererID() {
   return renderer_id_;
 }
 #endif
 
 GLShareGroup::~GLShareGroup() {
 }
 
 }  // namespace gfx