Split //ui/gl into //ui/gl + //ui/gi/init.

gpu/command_buffer/tests/gl_manager.cc

 // 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 "gpu/command_buffer/tests/gl_manager.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 #include <stddef.h>
@@ skipping 25 matching lines @@
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image_ref_counted_memory.h"
 #include "ui/gl/gl_share_group.h"
 #include "ui/gl/gl_surface.h"
+#include "ui/gl/init/gl_factory.h"
 
 #if defined(OS_MACOSX)
 #include "ui/gfx/mac/io_surface.h"
 #include "ui/gl/gl_image_io_surface.h"
 #endif
 
 namespace gpu {
 namespace {
 
 uint64_t g_next_command_buffer_id = 0;
@@ skipping 249 matching lines @@
     decoder_->SetForceShaderNameHashingForTest(true);
   }
   command_buffer_.reset(new CommandBufferService(
       decoder_->GetContextGroup()->transfer_buffer_manager()));
 
   executor_.reset(new CommandExecutor(command_buffer_.get(), decoder_.get(),
                                       decoder_.get()));
 
   decoder_->set_engine(executor_.get());
 
-  surface_ = gfx::GLSurface::CreateOffscreenGLSurface(gfx::Size());
+  surface_ = gl::init::CreateOffscreenGLSurface(gfx::Size());
   ASSERT_TRUE(surface_.get() != NULL) << "could not create offscreen surface";
 
   if (base_context_) {
     context_ = scoped_refptr<gfx::GLContext>(new gpu::GLContextVirtual(
         share_group_.get(), base_context_->get(), decoder_->AsWeakPtr()));
     ASSERT_TRUE(context_->Initialize(
         surface_.get(), gfx::PreferIntegratedGpu));
   } else {
     if (real_gl_context) {
       context_ = scoped_refptr<gfx::GLContext>(new gpu::GLContextVirtual(
           share_group_.get(), real_gl_context, decoder_->AsWeakPtr()));
       ASSERT_TRUE(context_->Initialize(
           surface_.get(), gfx::PreferIntegratedGpu));
     } else {
-      context_ = gfx::GLContext::CreateGLContext(share_group_.get(),
-                                                 surface_.get(),
-                                                 gpu_preference);
+      context_ = gl::init::CreateGLContext(share_group_.get(), surface_.get(),
+                                           gpu_preference);
     }
   }
   ASSERT_TRUE(context_.get() != NULL) << "could not create GL context";
 
   ASSERT_TRUE(context_->MakeCurrent(surface_.get()));
 
   if (!decoder_->Initialize(surface_.get(), context_.get(), true, options.size,
                             ::gpu::gles2::DisallowedFeatures(), attribs)) {
     return;
   }
@@ skipping 42 matching lines @@
   MakeCurrent();
 }
 
 void GLManager::SetupBaseContext() {
   if (use_count_) {
     #if defined(OS_ANDROID)
       base_share_group_ = new scoped_refptr<gfx::GLShareGroup>(
           new gfx::GLShareGroup);
       gfx::Size size(4, 4);
       base_surface_ = new scoped_refptr<gfx::GLSurface>(
-          gfx::GLSurface::CreateOffscreenGLSurface(size));
+          gl::init::CreateOffscreenGLSurface(size));
       gfx::GpuPreference gpu_preference(gfx::PreferDiscreteGpu);
-      base_context_ = new scoped_refptr<gfx::GLContext>(
-          gfx::GLContext::CreateGLContext(base_share_group_->get(),
-                                          base_surface_->get(),
-                                          gpu_preference));
+      base_context_ =
+          new scoped_refptr<gfx::GLContext>(gl::init::CreateGLContext(
+              base_share_group_->get(), base_surface_->get(), gpu_preference));
     #endif
   }
   ++use_count_;
 }
 
 void GLManager::OnFenceSyncRelease(uint64_t release) {
   DCHECK(sync_point_client_);
   DCHECK(!sync_point_client_->client_state()->IsFenceSyncReleased(release));
   sync_point_client_->ReleaseFenceSync(release);
 }
@@ skipping 216 matching lines @@
 
   // Something went wrong, just run the callback now.
   callback.Run();
 }
 
 bool GLManager::CanWaitUnverifiedSyncToken(const gpu::SyncToken* sync_token) {
   return false;
 }
 
 }  // namespace gpu