GLContext no longer holds a pointer to a GLSurface.

gpu/command_buffer/service/gpu_scheduler.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 "gpu/command_buffer/service/gpu_scheduler.h"
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "ui/gfx/gl/gl_context.h"
 #include "ui/gfx/gl/gl_bindings.h"
+#include "ui/gfx/gl/gl_surface.h"
 
 using ::base::SharedMemory;
 
 namespace gpu {
 
 GpuScheduler::GpuScheduler(CommandBuffer* command_buffer,
                            gles2::ContextGroup* group)
     : command_buffer_(command_buffer),
       commands_per_update_(100),
       unscheduled_count_(0),
@@ skipping 22 matching lines @@
   DCHECK(command_buffer);
   decoder_.reset(decoder);
   parser_.reset(parser);
 }
 
 GpuScheduler::~GpuScheduler() {
   Destroy();
 }
 
 bool GpuScheduler::InitializeCommon(
+    gfx::GLSurface* surface,
     gfx::GLContext* context,
     const gfx::Size& size,
     const gles2::DisallowedExtensions& disallowed_extensions,
     const char* allowed_extensions,
     const std::vector<int32>& attribs,
     gles2::GLES2Decoder* parent_decoder,
     uint32 parent_texture_id) {
   DCHECK(context);
 
-  if (!context->MakeCurrent())
+  if (!context->MakeCurrent(surface))
     return false;
 
   // Do not limit to a certain number of commands before scheduling another
   // update when rendering onscreen.
-  if (!context->IsOffscreen())
+  if (!surface->IsOffscreen())
     commands_per_update_ = INT_MAX;
 
   // Map the ring buffer and create the parser.
   Buffer ring_buffer = command_buffer_->GetRingBuffer();
   if (ring_buffer.ptr) {
     parser_.reset(new CommandParser(ring_buffer.ptr,
                                     ring_buffer.size,
                                     0,
                                     ring_buffer.size,
                                     0,
                                     decoder_.get()));
   } else {
     parser_.reset(new CommandParser(NULL, 0, 0, 0, 0,
                                     decoder_.get()));
   }
 
   // Initialize the decoder with either the view or pbuffer GLContext.
-  if (!decoder_->Initialize(context,
+  // TODO(apatrick): The GpuScheduler should know nothing about the surface the
+  // decoder is rendering to. Get rid of the surface parameter.
+  if (!decoder_->Initialize(surface,
+                            context,
                             size,
                             disallowed_extensions,
                             allowed_extensions,
                             attribs,
                             parent_decoder,
                             parent_texture_id)) {
     LOG(ERROR) << "GpuScheduler::InitializeCommon failed because decoder "
                << "failed to initialize.";
     Destroy();
     return false;
@@ skipping 158 matching lines @@
   command_processed_callback_.reset(callback);
 }
 
 void GpuScheduler::ScheduleProcessCommands() {
   MessageLoop::current()->PostTask(
       FROM_HERE,
       method_factory_.NewRunnableMethod(&GpuScheduler::ProcessCommands));
 }
 
 }  // namespace gpu