Revert of Use a single CGLContextObj to draw and update the IOSurface

content/browser/compositor/io_surface_texture_mac.mm

 // 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/browser/compositor/io_surface_texture_mac.h"
 
 #include <OpenGL/CGLIOSurface.h>
 #include <OpenGL/CGLRenderers.h>
 #include <OpenGL/OpenGL.h>
 #include <OpenGL/gl.h>
@@ skipping 17 matching lines @@
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/scoped_ns_graphics_context_save_gstate_mac.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gl/gl_context.h"
 
 namespace content {
 
 // static
 scoped_refptr<IOSurfaceTexture> IOSurfaceTexture::Create() {
-  scoped_refptr<IOSurfaceContext> context = IOSurfaceContext::Get();
-  if (!context.get()) {
+  scoped_refptr<IOSurfaceContext> offscreen_context =
+      IOSurfaceContext::Get(
+          IOSurfaceContext::kOffscreenContext);
+  if (!offscreen_context.get()) {
     LOG(ERROR) << "Failed to create context for offscreen operations";
     return NULL;
   }
 
-  return new IOSurfaceTexture(context);
+  return new IOSurfaceTexture(offscreen_context);
 }
 
 IOSurfaceTexture::IOSurfaceTexture(
-    const scoped_refptr<IOSurfaceContext>& context)
-    : context_(context),
+    const scoped_refptr<IOSurfaceContext>& offscreen_context)
+    : offscreen_context_(offscreen_context),
       texture_(0),
       gl_error_(GL_NO_ERROR),
       eviction_queue_iterator_(eviction_queue_.Get().end()),
       eviction_has_been_drawn_since_updated_(false) {
-  CHECK(context_.get());
+  CHECK(offscreen_context_.get());
 }
 
 IOSurfaceTexture::~IOSurfaceTexture() {
   ReleaseIOSurfaceAndTexture();
-  context_ = NULL;
+  offscreen_context_ = NULL;
   DCHECK(eviction_queue_iterator_ == eviction_queue_.Get().end());
 }
 
 bool IOSurfaceTexture::DrawIOSurface() {
   TRACE_EVENT0("browser", "IOSurfaceTexture::DrawIOSurface");
 
   // If we have release the IOSurface, clear the screen to light grey and
   // early-out.
   if (!io_surface_) {
     glClearColor(0.9, 0.9, 0.9, 1);
@@ skipping 95 matching lines @@
 
   // Actual IOSurface size is rounded up to reduce reallocations during window
   // resize. Get the actual size to properly map the texture.
   gfx::Size rounded_size(IOSurfaceGetWidth(io_surface_),
                          IOSurfaceGetHeight(io_surface_));
 
   // Create the GL texture and set it to be backed by the IOSurface.
   CGLError cgl_error = kCGLNoError;
   {
     gfx::ScopedCGLSetCurrentContext scoped_set_current_context(
-        context_->cgl_context());
+        offscreen_context_->cgl_context());
     glGenTextures(1, &texture_);
     glBindTexture(GL_TEXTURE_RECTANGLE_ARB, texture_);
     glTexParameterf(
         GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameterf(
         GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     cgl_error = CGLTexImageIOSurface2D(
-        context_->cgl_context(),
+        offscreen_context_->cgl_context(),
         GL_TEXTURE_RECTANGLE_ARB,
         GL_RGBA,
         rounded_size.width(),
         rounded_size.height(),
         GL_BGRA,
         GL_UNSIGNED_INT_8_8_8_8_REV,
         io_surface_.get(),
         0 /* plane */);
     glBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);
     GetAndSaveGLError();
   }
 
   // Return failure if an error was encountered by CGL or GL.
   if (cgl_error != kCGLNoError) {
     LOG(ERROR) << "CGLTexImageIOSurface2D failed with CGL error: " << cgl_error;
     return false;
   }
   if (gl_error_ != GL_NO_ERROR) {
     LOG(ERROR) << "Hit GL error in SetIOSurface: " << gl_error_;
     return false;
   }
 
   ignore_result(error_runner.Release());
   return true;
 }
 
 void IOSurfaceTexture::ReleaseIOSurfaceAndTexture() {
   gfx::ScopedCGLSetCurrentContext scoped_set_current_context(
-      context_->cgl_context());
+      offscreen_context_->cgl_context());
 
   if (texture_) {
     glDeleteTextures(1, &texture_);
     texture_ = 0;
   }
   pixel_size_ = gfx::Size();
   io_surface_.reset();
 
   EvictionMarkEvicted();
 }
 
+bool IOSurfaceTexture::HasBeenPoisoned() const {
+  return offscreen_context_->HasBeenPoisoned();
+}
+
 GLenum IOSurfaceTexture::GetAndSaveGLError() {
   GLenum gl_error = glGetError();
   if (gl_error_ == GL_NO_ERROR)
     gl_error_ = gl_error;
   return gl_error;
 }
 
 void IOSurfaceTexture::EvictionMarkUpdated() {
   EvictionMarkEvicted();
   eviction_queue_.Get().push_back(this);
@@ skipping 48 matching lines @@
 }
 
 // static
 base::LazyInstance<IOSurfaceTexture::EvictionQueue>
     IOSurfaceTexture::eviction_queue_;
 
 // static
 bool IOSurfaceTexture::eviction_scheduled_ = false;
 
 }  // namespace content