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

components/mus/gles2/command_buffer_driver.cc

 // Copyright 2013 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 "components/mus/gles2/command_buffer_driver.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 15 matching lines @@
 #include "gpu/command_buffer/service/sync_point_manager.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/platform_handle/platform_handle_functions.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gfx/vsync_provider.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image_shared_memory.h"
 #include "ui/gl/gl_surface.h"
+#include "ui/gl/init/gl_factory.h"
 
 #if defined(USE_OZONE)
 #include "ui/gl/gl_image_ozone_native_pixmap.h"
 #endif
 
 namespace mus {
 
 namespace {
 
 // The first time polling a fence, delay some extra time to allow other
@@ skipping 33 matching lines @@
 bool CommandBufferDriver::Initialize(
     mojo::ScopedSharedBufferHandle shared_state,
     mojo::Array<int32_t> attribs) {
   DCHECK(CalledOnValidThread());
   gpu::gles2::ContextCreationAttribHelper attrib_helper;
   if (!attrib_helper.Parse(attribs.storage()))
     return false;
 
   const bool offscreen = widget_ == gfx::kNullAcceleratedWidget;
   if (offscreen) {
-    surface_ = gfx::GLSurface::CreateOffscreenGLSurface(gfx::Size(0, 0));
+    surface_ = gl::init::CreateOffscreenGLSurface(gfx::Size(0, 0));
   } else {
 #if defined(USE_OZONE)
     scoped_refptr<gfx::GLSurface> underlying_surface =
-        gfx::GLSurface::CreateSurfacelessViewGLSurface(widget_);
+        gl::init::CreateSurfacelessViewGLSurface(widget_);
     if (!underlying_surface)
-      underlying_surface = gfx::GLSurface::CreateViewGLSurface(widget_);
+      underlying_surface = gl::init::CreateViewGLSurface(widget_);
 #else
     scoped_refptr<gfx::GLSurface> underlying_surface =
-        gfx::GLSurface::CreateViewGLSurface(widget_);
+        gl::init::CreateViewGLSurface(widget_);
 #endif
     scoped_refptr<GLSurfaceAdapterMus> surface_adapter =
         new GLSurfaceAdapterMus(underlying_surface);
     surface_adapter->SetGpuCompletedSwapBuffersCallback(
         base::Bind(&CommandBufferDriver::OnGpuCompletedSwapBuffers,
                    weak_factory_.GetWeakPtr()));
     surface_ = surface_adapter;
 
     gfx::VSyncProvider* vsync_provider =
         surface_ ? surface_->GetVSyncProvider() : nullptr;
     if (vsync_provider) {
       vsync_provider->GetVSyncParameters(
           base::Bind(&CommandBufferDriver::OnUpdateVSyncParameters,
                      weak_factory_.GetWeakPtr()));
     }
   }
 
   if (!surface_.get())
     return false;
 
   // TODO(piman): virtual contexts, gpu preference.
-  context_ = gfx::GLContext::CreateGLContext(
+  context_ = gl::init::CreateGLContext(
       gpu_state_->share_group(), surface_.get(), gfx::PreferIntegratedGpu);
   if (!context_.get())
     return false;
 
   if (!context_->MakeCurrent(surface_.get()))
     return false;
 
   // TODO(piman): ShaderTranslatorCache is currently per-ContextGroup but
   // only needs to be per-thread.
   const bool bind_generates_resource = attrib_helper.bind_generates_resource;
@@ skipping 411 matching lines @@
 }
 
 void CommandBufferDriver::OnGpuCompletedSwapBuffers(gfx::SwapResult result) {
   DCHECK(CalledOnValidThread());
   if (client_) {
     client_->OnGpuCompletedSwapBuffers(result);
   }
 }
 
 }  // namespace mus