Move code in ui/gl/* from gfx:: to gl::

gpu/perftests/texture_upload_perftest.cc

 // Copyright 2015 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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
 #include <vector>
@@ skipping 172 matching lines @@
     // On Ozone, the backend initializes the event system using a UI
     // thread.
     base::MessageLoopForUI main_loop;
 #endif
     static bool gl_initialized = gl::init::InitializeGLOneOff();
     DCHECK(gl_initialized);
     // Initialize an offscreen surface and a gl context.
     surface_ = gl::init::CreateOffscreenGLSurface(gfx::Size());
     gl_context_ =
         gl::init::CreateGLContext(nullptr,  // share_group
-                                  surface_.get(), gfx::PreferIntegratedGpu);
+                                  surface_.get(), gl::PreferIntegratedGpu);
     ui::ScopedMakeCurrent smc(gl_context_.get(), surface_.get());
     glGenTextures(1, &color_texture_);
     glBindTexture(GL_TEXTURE_2D, color_texture_);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, fbo_size_.width(),
                  fbo_size_.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
 
@@ skipping 11 matching lines @@
     if (gpu_timing_client_->IsAvailable()) {
       LOG(INFO) << "Gpu timing initialized with timer type: "
                 << gpu_timing_client_->GetTimerTypeName();
     } else {
       LOG(WARNING) << "Can't initialize gpu timing";
     }
     // Prepare a simple program and a vertex buffer that will be
     // used to draw a quad on the offscreen surface.
     vertex_shader_ = LoadShader(GL_VERTEX_SHADER, kVertexShader);
 
-    bool is_gles = gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2;
+    bool is_gles = gl::GetGLImplementation() == gl::kGLImplementationEGLGLES2;
     fragment_shader_ = LoadShader(
         GL_FRAGMENT_SHADER,
         base::StringPrintf("%s%s", is_gles ? kShaderDefaultFloatPrecision : "",
                            kFragmentShader).c_str());
     program_object_ = glCreateProgram();
     CHECK_NE(0u, program_object_);
 
     glAttachShader(program_object_, vertex_shader_);
     glAttachShader(program_object_, fragment_shader_);
     glBindAttribLocation(program_object_, 0, "a_position");
@@ skipping 137 matching lines @@
     glFinish();
     CheckNoGlError("glFinish");
     finish_timers.Record();
 
     std::vector<uint8_t> pixels_rendered(size.GetArea() * 4);
     glReadPixels(0, 0, size.width(), size.height(), GL_RGBA, GL_UNSIGNED_BYTE,
                  &pixels_rendered[0]);
     CheckNoGlError("glReadPixels");
     EXPECT_TRUE(
         CompareBufferToRGBABuffer(format, size, pixels, pixels_rendered))
-        << "Format is: " << gfx::GLEnums::GetStringEnum(format);
+        << "Format is: " << gl::GLEnums::GetStringEnum(format);
 
     std::vector<Measurement> measurements;
     bool gpu_timer_errors =
         gpu_timing_client_->IsAvailable() &&
         gpu_timing_client_->CheckAndResetTimerErrors();
     if (!gpu_timer_errors) {
       measurements.push_back(tex_timers.GetAsMeasurement(
           subimage ? "texsubimage2d" : "teximage2d"));
       measurements.push_back(
           first_draw_timers.GetAsMeasurement("firstdrawarrays"));
@@ skipping 20 matching lines @@
       successful_runs++;
       for (const Measurement& measurement : run) {
         auto& aggregate = aggregates[measurement.name];
         aggregate.name = measurement.name;
         aggregate.Increment(measurement);
       }
     }
     glDeleteTextures(1, &texture_id);
 
     std::string graph_name = base::StringPrintf(
-        "%d_%s", size.width(), gfx::GLEnums::GetStringEnum(format).c_str());
+        "%d_%s", size.width(), gl::GLEnums::GetStringEnum(format).c_str());
     if (subimage) {
       graph_name += "_sub";
     }
 
     if (successful_runs) {
       for (const auto& entry : aggregates) {
         const auto m = entry.second.Divide(successful_runs);
         m.PrintResult(graph_name);
       }
     }
     perf_test::PrintResult("sample_runs", "", graph_name,
                            static_cast<size_t>(successful_runs), "laps", true);
   }
 
   const gfx::Size fbo_size_;  // for the fbo
-  scoped_refptr<gfx::GLContext> gl_context_;
-  scoped_refptr<gfx::GLSurface> surface_;
-  scoped_refptr<gfx::GPUTimingClient> gpu_timing_client_;
+  scoped_refptr<gl::GLContext> gl_context_;
+  scoped_refptr<gl::GLSurface> surface_;
+  scoped_refptr<gl::GPUTimingClient> gpu_timing_client_;
 
   GLuint color_texture_ = 0;
   GLuint framebuffer_object_ = 0;
   GLuint vertex_shader_ = 0;
   GLuint fragment_shader_ = 0;
   GLuint program_object_ = 0;
   GLint sampler_location_ = -1;
   GLint translation_location_ = -1;
   GLuint vertex_buffer_ = 0;
 
@@ skipping 98 matching lines @@
                           gpu_timing_client_->CheckAndResetTimerErrors();
   if (!gpu_timer_errors) {
     upload_and_draw_timers.GetAsMeasurement("upload_and_draw")
         .PrintResult("renaming");
     finish_timers.GetAsMeasurement("finish").PrintResult("renaming");
   }
 }
 
 }  // namespace
 }  // namespace gpu