GLContext no longer holds a pointer to a GLSurface.

ui/gfx/gl/gl_context_egl.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_egl.h"
 
 #include "build/build_config.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "third_party/angle/include/EGL/egl.h"
@@ skipping 14 matching lines @@
 
 std::string GLContextEGL::GetExtensions() {
   const char* extensions = eglQueryString(GLSurfaceEGL::GetDisplay(),
                                           EGL_EXTENSIONS);
   if (!extensions)
     return GLContext::GetExtensions();
 
   return GLContext::GetExtensions() + " " + extensions;
 }
 
-GLContextEGL::GLContextEGL(GLSurfaceEGL* surface)
-    : surface_(surface),
-      context_(NULL)
+GLContextEGL::GLContextEGL()
+    : context_(NULL)
 {
 }
 
 GLContextEGL::~GLContextEGL() {
   Destroy();
 }
 
-bool GLContextEGL::Initialize(GLContext* shared_context) {
+bool GLContextEGL::Initialize(GLContext* shared_context,
+                              GLSurface* compatible_surface) {
+  DCHECK(compatible_surface);
   DCHECK(!context_);
 
   static const EGLint kContextAttributes[] = {
     EGL_CONTEXT_CLIENT_VERSION, 2,
     EGL_NONE
   };
 
   context_ = eglCreateContext(
       GLSurfaceEGL::GetDisplay(),
       GLSurfaceEGL::GetConfig(),
       shared_context ? shared_context->GetHandle() : NULL,
       kContextAttributes);
   if (!context_) {
     LOG(ERROR) << "eglCreateContext failed with error "
                << GetLastEGLErrorString();
     Destroy();
     return false;
   }
 
-  if (!MakeCurrent()) {
-    LOG(ERROR) << "MakeCurrent failed.";
-    Destroy();
-    return false;
-  }
-
-  if (!InitializeCommon()) {
-    LOG(ERROR) << "GLContext::InitializeCommon failed.";
-    Destroy();
-    return false;
-  }
-
   return true;
 }
 
 void GLContextEGL::Destroy() {
   if (context_) {
     if (!eglDestroyContext(GLSurfaceEGL::GetDisplay(), context_)) {
       LOG(ERROR) << "eglDestroyContext failed with error "
                  << GetLastEGLErrorString();
     }
 
     context_ = NULL;
   }
-
-  if (surface_.get()) {
-    surface_->Destroy();
-    surface_.reset();
-  }
 }
 
-bool GLContextEGL::MakeCurrent() {
+bool GLContextEGL::MakeCurrent(GLSurface* surface) {
   DCHECK(context_);
-  if (IsCurrent())
+  if (IsCurrent(surface))
       return true;
 
   if (!eglMakeCurrent(GLSurfaceEGL::GetDisplay(),
-                      surface_->GetHandle(),
-                      surface_->GetHandle(),
+                      surface->GetHandle(),
+                      surface->GetHandle(),
                       context_)) {
     VLOG(1) << "eglMakeCurrent failed with error "
             << GetLastEGLErrorString();
     return false;
   }
 
   return true;
 }
 
-void GLContextEGL::ReleaseCurrent() {
-  if (!IsCurrent())
+void GLContextEGL::ReleaseCurrent(GLSurface* surface) {
+  if (!IsCurrent(surface))
     return;
 
   eglMakeCurrent(GLSurfaceEGL::GetDisplay(),
                  EGL_NO_SURFACE,
                  EGL_NO_SURFACE,
                  EGL_NO_CONTEXT);
 }
 
-bool GLContextEGL::IsCurrent() {
+bool GLContextEGL::IsCurrent(GLSurface* surface) {
   DCHECK(context_);
-  return context_ == eglGetCurrentContext() &&
-      surface_->GetHandle() == eglGetCurrentSurface(EGL_DRAW);
-}
+  if (context_ != eglGetCurrentContext())
+    return false;
 
-bool GLContextEGL::IsOffscreen() {
-  // TODO(apatrick): remove this from GLContext interface.
-  return surface_->IsOffscreen();
-}
+  if (surface) {
+    if (surface->GetHandle() != eglGetCurrentSurface(EGL_DRAW))
+      return false;
+  }
 
-bool GLContextEGL::SwapBuffers() {
-  // TODO(apatrick): remove this from GLContext interface.
-  return surface_->SwapBuffers();
-}
-
-gfx::Size GLContextEGL::GetSize() {
-  // TODO(apatrick): remove this from GLContext interface.
-  return surface_->GetSize();
-}
-
-GLSurface* GLContextEGL::GetSurface() {
-  // TODO(apatrick): remove this from GLContext interface.
-  return surface_.get();
+  return true;
 }
 
 void* GLContextEGL::GetHandle() {
   return context_;
 }
 
 void GLContextEGL::SetSwapInterval(int interval) {
-  DCHECK(IsCurrent());
+  DCHECK(IsCurrent(NULL));
   if (!eglSwapInterval(GLSurfaceEGL::GetDisplay(), interval)) {
     LOG(ERROR) << "eglSwapInterval failed with error "
                << GetLastEGLErrorString();
   }
 }
 
 }  // namespace gfx