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

gpu/config/gpu_info_collector_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 
 #include "base/strings/string_split.h"
 #include "gpu/config/gpu_info.h"
 #include "gpu/config/gpu_info_collector.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_mock.h"
 #include "ui/gl/test/gl_surface_test_support.h"
 
-using ::gfx::MockGLInterface;
+using ::gl::MockGLInterface;
 using ::testing::Return;
 using ::testing::SetArgPointee;
 using ::testing::_;
 
 namespace {
 
 // Allows testing of all configurations on all operating systems.
 enum MockedOperatingSystemKind {
   kMockedAndroid,
   kMockedLinux,
@@ skipping 14 matching lines @@
 
 class GPUInfoCollectorTest
     : public testing::Test,
       public ::testing::WithParamInterface<MockedOperatingSystemKind> {
  public:
   GPUInfoCollectorTest() {}
   ~GPUInfoCollectorTest() override {}
 
   void SetUp() override {
     testing::Test::SetUp();
-    gfx::SetGLGetProcAddressProc(gfx::MockGLInterface::GetGLProcAddress);
-    gfx::GLSurfaceTestSupport::InitializeOneOffWithMockBindings();
-    gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>());
-    ::gfx::MockGLInterface::SetGLInterface(gl_.get());
+    gl::SetGLGetProcAddressProc(gl::MockGLInterface::GetGLProcAddress);
+    gl::GLSurfaceTestSupport::InitializeOneOffWithMockBindings();
+    gl_.reset(new ::testing::StrictMock<::gl::MockGLInterface>());
+    ::gl::MockGLInterface::SetGLInterface(gl_.get());
     switch (GetParam()) {
       case kMockedAndroid: {
         test_values_.gpu.vendor_id = 0;  // not implemented
         test_values_.gpu.device_id = 0;  // not implemented
         test_values_.driver_vendor = "";  // not implemented
         test_values_.driver_version = "14.0";
         test_values_.pixel_shader_version = "1.00";
         test_values_.vertex_shader_version = "1.00";
         test_values_.gl_renderer = "Adreno (TM) 320";
         test_values_.gl_vendor = "Qualcomm";
@@ skipping 58 matching lines @@
       }
     }
 
     test_values_.can_lose_context = false;
 
     EXPECT_CALL(*gl_, GetString(GL_VERSION))
         .WillRepeatedly(Return(reinterpret_cast<const GLubyte*>(
             test_values_.gl_version.c_str())));
 
     // Now that that expectation is set up, we can call this helper function.
-    if (gfx::WillUseGLGetStringForExtensions()) {
+    if (gl::WillUseGLGetStringForExtensions()) {
       EXPECT_CALL(*gl_, GetString(GL_EXTENSIONS))
           .WillRepeatedly(Return(reinterpret_cast<const GLubyte*>(
               test_values_.gl_extensions.c_str())));
     } else {
       split_extensions_.clear();
       split_extensions_ = base::SplitString(
           test_values_.gl_extensions, " ",
           base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
       EXPECT_CALL(*gl_, GetIntegerv(GL_NUM_EXTENSIONS, _))
           .WillRepeatedly(SetArgPointee<1>(split_extensions_.size()));
@@ skipping 11 matching lines @@
             test_values_.gl_vendor.c_str())));
     EXPECT_CALL(*gl_, GetString(GL_RENDERER))
         .WillRepeatedly(Return(reinterpret_cast<const GLubyte*>(
             test_values_.gl_renderer.c_str())));
     EXPECT_CALL(*gl_, GetIntegerv(GL_MAX_SAMPLES, _))
         .WillOnce(SetArgPointee<1>(8))
         .RetiresOnSaturation();
   }
 
   void TearDown() override {
-    ::gfx::MockGLInterface::SetGLInterface(NULL);
+    ::gl::MockGLInterface::SetGLInterface(NULL);
     gl_.reset();
-    gfx::ClearGLBindings();
+    gl::ClearGLBindings();
 
     testing::Test::TearDown();
   }
 
  public:
   // Use StrictMock to make 100% sure we know how GL will be called.
-  std::unique_ptr<::testing::StrictMock<::gfx::MockGLInterface>> gl_;
+  std::unique_ptr<::testing::StrictMock<::gl::MockGLInterface>> gl_;
   GPUInfo test_values_;
   const char* gl_shading_language_version_ = nullptr;
 
   // Persistent storage is needed for the split extension string.
   std::vector<std::string> split_extensions_;
 };
 
 INSTANTIATE_TEST_CASE_P(GPUConfig,
                         GPUInfoCollectorTest,
                         ::testing::ValuesIn(kMockedOperatingSystemKinds));
@@ skipping 165 matching lines @@
 
   gpu_info.gl_vendor = "Google Corporation";
   gpu_info.gl_renderer = "Chrome GPU Team";
   IdentifyActiveGPU(&gpu_info);
   EXPECT_FALSE(gpu_info.gpu.active);
   EXPECT_FALSE(gpu_info.secondary_gpus[0].active);
 }
 
 }  // namespace gpu