Fix GLES2 Conformance test support

gpu/gles2_conform_support/egl/display.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/gles2_conform_support/egl/display.h"
 
 #include <vector>
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "gpu/command_buffer/client/gles2_lib.h"
@@ skipping 12 matching lines @@
     : display_id_(display_id),
       is_initialized_(false),
       transfer_buffer_id_(-1) {
 }
 
 Display::~Display() {
   gles2::Terminate();
 }
 
 bool Display::Initialize() {
-  scoped_ptr<gpu::CommandBufferService> command_buffer(
-      new gpu::CommandBufferService);
-  if (!command_buffer->Initialize())
-    return false;
-
-  int32 transfer_buffer_id =
-      command_buffer->CreateTransferBuffer(kTransferBufferSize, -1);
-  gpu::Buffer transfer_buffer =
-      command_buffer->GetTransferBuffer(transfer_buffer_id);
-  if (transfer_buffer.ptr == NULL)
-    return false;
-
-  scoped_ptr<gpu::gles2::GLES2CmdHelper> cmd_helper(
-      new gpu::gles2::GLES2CmdHelper(command_buffer.get()));
-  if (!cmd_helper->Initialize(kCommandBufferSize))
-    return false;
-
   gles2::Initialize();
-
   is_initialized_ = true;
-  command_buffer_.reset(command_buffer.release());
-  transfer_buffer_id_ = transfer_buffer_id;
-  gles2_cmd_helper_.reset(cmd_helper.release());
   return true;
 }
 
 bool Display::IsValidConfig(EGLConfig config) {
   return (config != NULL) && (config == config_.get());
 }
 
 bool Display::GetConfigs(EGLConfig* configs,
                          EGLint config_size,
                          EGLint* num_config) {
@@ skipping 30 matching lines @@
 }
 
 EGLSurface Display::CreateWindowSurface(EGLConfig config,
                                         EGLNativeWindowType win,
                                         const EGLint* attrib_list) {
   if (surface_ != NULL) {
     // We do not support more than one window surface.
     return EGL_NO_SURFACE;
   }
 
+  scoped_ptr<gpu::CommandBufferService> command_buffer(
+      new gpu::CommandBufferService);
+  if (!command_buffer->Initialize())
+    return false;
+
   gpu::gles2::ContextGroup::Ref group(new gpu::gles2::ContextGroup(true));
 
   decoder_.reset(gpu::gles2::GLES2Decoder::Create(group.get()));
   if (!decoder_.get())
     return EGL_NO_SURFACE;
 
-  gpu_scheduler_.reset(new gpu::GpuScheduler(command_buffer_.get(),
+  gpu_scheduler_.reset(new gpu::GpuScheduler(command_buffer.get(),
                                              decoder_.get(),
                                              NULL));
 
   decoder_->set_engine(gpu_scheduler_.get());
 
   gl_surface_ = gfx::GLSurface::CreateViewGLSurface(false, win);
   if (!gl_surface_.get())
     return EGL_NO_SURFACE;
 
   gl_context_ = gfx::GLContext::CreateGLContext(NULL,
                                                 gl_surface_.get(),
                                                 gfx::PreferDiscreteGpu);
   if (!gl_context_.get())
     return EGL_NO_SURFACE;
 
   std::vector<int32> attribs;
   if (!decoder_->Initialize(gl_surface_.get(),
                             gl_context_.get(),
                             gfx::Size(),
                             gpu::gles2::DisallowedFeatures(),
                             NULL,
                             attribs)) {
     return EGL_NO_SURFACE;
   }
 
-  command_buffer_->SetPutOffsetChangeCallback(
+  command_buffer->SetPutOffsetChangeCallback(
       base::Bind(&gpu::GpuScheduler::PutChanged,
                  base::Unretained(gpu_scheduler_.get())));
-  command_buffer_->SetGetBufferChangeCallback(
+  command_buffer->SetGetBufferChangeCallback(
       base::Bind(&gpu::GpuScheduler::SetGetBuffer,
                  base::Unretained(gpu_scheduler_.get())));
 
+  scoped_ptr<gpu::gles2::GLES2CmdHelper> cmd_helper(
+      new gpu::gles2::GLES2CmdHelper(command_buffer.get()));
+  if (!cmd_helper->Initialize(kCommandBufferSize))
+    return false;
+
+  int32 transfer_buffer_id =
+      command_buffer->CreateTransferBuffer(kTransferBufferSize, -1);
+  gpu::Buffer transfer_buffer =
+      command_buffer->GetTransferBuffer(transfer_buffer_id);
+  if (transfer_buffer.ptr == NULL)
+    return false;
+
+  command_buffer_.reset(command_buffer.release());
+  transfer_buffer_id_ = transfer_buffer_id;
+  gles2_cmd_helper_.reset(cmd_helper.release());
   surface_.reset(new Surface(win));
 
   return surface_.get();
 }
 
 void Display::DestroySurface(EGLSurface surface) {
   DCHECK(IsValidSurface(surface));
   gpu_scheduler_.reset();
   if (decoder_.get()) {
     decoder_->Destroy();
@@ skipping 51 matching lines @@
   } else {
     DCHECK(IsValidSurface(draw));
     DCHECK(IsValidSurface(read));
     DCHECK(IsValidContext(ctx));
     gles2::SetGLContext(context_.get());
   }
   return true;
 }
 
 }  // namespace egl