This change adds the apple software renderer as an option on Chrome/Mac. It's enabled by passing...

ui/gfx/gl/gl_context_cgl.cc

 // Copyright (c) 2011 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/gfx/gl/gl_context_cgl.h"
 
+#include <OpenGL/CGLRenderers.h>
 #include <vector>
 
 #include "base/logging.h"
 #include "ui/gfx/gl/gl_bindings.h"
+#include "ui/gfx/gl/gl_implementation.h"
 #include "ui/gfx/gl/gl_surface_cgl.h"
 
 namespace gfx {
 
 GLContextCGL::GLContextCGL(GLShareGroup* share_group)
   : GLContext(share_group),
     context_(NULL),
     gpu_preference_(PreferIntegratedGpu) {
 }
 
@@ skipping 14 matching lines @@
       return false;
   }
 
   std::vector<CGLPixelFormatAttribute> attribs;
   attribs.push_back(kCGLPFAPBuffer);
   bool using_offline_renderer =
       SupportsDualGpus() && gpu_preference == PreferIntegratedGpu;
   if (using_offline_renderer) {
     attribs.push_back(kCGLPFAAllowOfflineRenderers);
   }
+  if (GetGLImplementation() == kGLImplementationAppleGL) {
+    attribs.push_back(kCGLPFARendererID);
+    attribs.push_back((CGLPixelFormatAttribute) kCGLRendererGenericFloatID);

[Ken Russell (switch to Gerrit), 2011/12/06 19:23:47]

What are the interactions with (a) the dual-GPU code and (b) the IOSurface
support in the browser? In what environments is this new code path expected to
work (DRT, browser/UI tests, full Chrome)?

[Stephen White, 2011/12/06 19:49:04]

Since this is strictly a software renderer, it shouldn't be affected by the
dual-gpu code, so perhaps it should also skip the kCGLPFAAllowOfflineRenderers
flag above it in that case (not sure).  Is there a test I can run to mock a
dual-GPU mac?  

Regardless, since this new code only executes if --use-gl=apple is passed, I
don't think it will affect existing usage.
It works in DRT and full Chrome, but it's not the default on any of those,
obviously (any more than --use-gl=desktop is on Windows, for example).  Don't
know about browser/ui tests.

[Ken Russell (switch to Gerrit), 2011/12/06 22:49:45]

Sorry, there isn't currently. I don't know how to mock out system level APIs
like these. Presumably we could do this by reimplementing the CGL layer and
using e.g. Mesa as the backend renderer. If you have suggestions on how we can
test this behavior in isolation I would appreciate them. In the interim we can
test on dual-GPU machines running 10.7.x if you can provide the test scenarios.
Sounds reasonable. Was mainly wondering if the test setup would be affected.
Interesting. Good to know that it works with the other IOSurface infrastructure.

+  }
   attribs.push_back((CGLPixelFormatAttribute) 0);
 
   CGLPixelFormatObj format;
   GLint num_pixel_formats;
   if (CGLChoosePixelFormat(&attribs.front(),
                            &format,
                            &num_pixel_formats) != kCGLNoError) {
     LOG(ERROR) << "Error choosing pixel format.";
     return false;
   }
@@ skipping 24 matching lines @@
     CGLDestroyContext(static_cast<CGLContextObj>(context_));
     context_ = NULL;
   }
 }
 
 bool GLContextCGL::MakeCurrent(GLSurface* surface) {
   DCHECK(context_);
   if (IsCurrent(surface))
     return true;
 
-  if (CGLSetPBuffer(static_cast<CGLContextObj>(context_),
-                    static_cast<CGLPBufferObj>(surface->GetHandle()),
-                    0,
-                    0,
-                    0) != kCGLNoError) {
-    LOG(ERROR) << "Error attaching pbuffer to context.";
-    Destroy();
-    return false;
-  }
-
   if (CGLSetCurrentContext(
       static_cast<CGLContextObj>(context_)) != kCGLNoError) {
     LOG(ERROR) << "Unable to make gl context current.";
     return false;
   }
 
   SetCurrent(this, surface);
   if (!InitializeExtensionBindings()) {
     ReleaseCurrent(surface);
     return false;
   }
 
   if (!surface->OnMakeCurrent(this)) {
     LOG(ERROR) << "Unable to make gl context current.";
     return false;
   }
 
   return true;
 }
 
 void GLContextCGL::ReleaseCurrent(GLSurface* surface) {
   if (!IsCurrent(surface))
     return;
 
   SetCurrent(NULL, NULL);
   CGLSetCurrentContext(NULL);
-  CGLSetPBuffer(static_cast<CGLContextObj>(context_), NULL, 0, 0, 0);
 }
 
 bool GLContextCGL::IsCurrent(GLSurface* surface) {
   bool native_context_is_current = CGLGetCurrentContext() == context_;
 
   // If our context is current then our notion of which GLContext is
   // current must be correct. On the other hand, third-party code
   // using OpenGL might change the current context.
   DCHECK(!native_context_is_current || (GetCurrent() == this));
 
   if (!native_context_is_current)
     return false;
 
-  if (surface) {
-    CGLPBufferObj current_surface = NULL;
-    GLenum face;
-    GLint level;
-    GLint screen;
-    CGLGetPBuffer(static_cast<CGLContextObj>(context_),
-                  &current_surface,
-                  &face,
-                  &level,
-                  &screen);
-    if (current_surface != surface->GetHandle())
-      return false;
-  }
-
   return true;
 }
 
 void* GLContextCGL::GetHandle() {
   return context_;
 }
 
 void GLContextCGL::SetSwapInterval(int interval) {
   DCHECK(IsCurrent(NULL));
   LOG(WARNING) << "GLContex: GLContextCGL::SetSwapInterval is ignored.";
 }
 
 GpuPreference GLContextCGL::GetGpuPreference() {
   return gpu_preference_;
 }
 
 }  // namespace gfx