Update from chromium https://crrev.com/301725/

gpu/command_buffer/service/program_manager_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 "gpu/command_buffer/service/program_manager.h"
 
 #include <algorithm>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 25 matching lines @@
 
 namespace {
 const uint32 kMaxVaryingVectors = 8;
 
 void ShaderCacheCb(const std::string& key, const std::string& shader) {}
 }  // namespace anonymous
 
 class ProgramManagerTest : public GpuServiceTest {
  public:
   ProgramManagerTest() : manager_(NULL, kMaxVaryingVectors) { }
-  virtual ~ProgramManagerTest() {
-    manager_.Destroy(false);
-  }
+  ~ProgramManagerTest() override { manager_.Destroy(false); }
 
  protected:
   ProgramManager manager_;
 };
 
 TEST_F(ProgramManagerTest, Basic) {
   const GLuint kClient1Id = 1;
   const GLuint kService1Id = 11;
   const GLuint kClient2Id = 2;
   // Check we can create program.
@@ skipping 65 matching lines @@
   EXPECT_FALSE(program1->CanLink());
   EXPECT_TRUE(program1->log_info() == NULL);
 }
 
 class ProgramManagerWithShaderTest : public GpuServiceTest {
  public:
   ProgramManagerWithShaderTest()
       :  manager_(NULL, kMaxVaryingVectors), program_(NULL) {
   }
 
-  virtual ~ProgramManagerWithShaderTest() {
+  ~ProgramManagerWithShaderTest() override {
     manager_.Destroy(false);
     shader_manager_.Destroy(false);
   }
 
   static const GLint kNumVertexAttribs = 16;
 
   static const GLuint kClientProgramId = 123;
   static const GLuint kServiceProgramId = 456;
   static const GLuint kVertexShaderClientId = 201;
   static const GLuint kFragmentShaderClientId = 202;
@@ skipping 20 matching lines @@
   static const GLint kBadAttribIndex = kNumVertexAttribs;
 
   static const char* kUniform1Name;
   static const char* kUniform2Name;
   static const char* kUniform2NameWithArrayIndex;
   static const char* kUniform3Name;
   static const char* kUniform3NameWithArrayIndex;
   static const GLint kUniform1Size = 1;
   static const GLint kUniform2Size = 3;
   static const GLint kUniform3Size = 2;
-  static const int kUniform1Precision = SH_PRECISION_LOWP;
-  static const int kUniform2Precision = SH_PRECISION_MEDIUMP;
-  static const int kUniform3Precision = SH_PRECISION_HIGHP;
+  static const int kUniform1Precision = GL_LOW_FLOAT;
+  static const int kUniform2Precision = GL_MEDIUM_INT;
+  static const int kUniform3Precision = GL_HIGH_FLOAT;
   static const int kUniform1StaticUse = 1;
   static const int kUniform2StaticUse = 1;
   static const int kUniform3StaticUse = 1;
   static const GLint kUniform1FakeLocation = 0;  // These are hard coded
   static const GLint kUniform2FakeLocation = 1;  // to match
   static const GLint kUniform3FakeLocation = 2;  // ProgramManager.
   static const GLint kUniform1RealLocation = 11;
   static const GLint kUniform2RealLocation = 22;
   static const GLint kUniform3RealLocation = 33;
   static const GLint kUniform1DesiredLocation = -1;
@@ skipping 20 matching lines @@
 
   typedef struct {
     GLenum type;
     GLint size;
     GLenum precision;
     bool static_use;
     std::string name;
     VarCategory category;
   } VarInfo;
 
-  virtual void SetUp() {
+  void SetUp() override {
     GpuServiceTest::SetUp();
 
     SetupDefaultShaderExpectations();
 
     Shader* vertex_shader = shader_manager_.CreateShader(
         kVertexShaderClientId, kVertexShaderServiceId, GL_VERTEX_SHADER);
     Shader* fragment_shader =
         shader_manager_.CreateShader(
             kFragmentShaderClientId, kFragmentShaderServiceId,
             GL_FRAGMENT_SHADER);
@@ skipping 894 matching lines @@
   // Set up shader
   const GLuint kVShaderClientId = 1;
   const GLuint kVShaderServiceId = 11;
   const GLuint kFShaderClientId = 2;
   const GLuint kFShaderServiceId = 12;
   AttributeMap attrib_map;
   for (uint32 ii = 0; ii < kNumAttribs; ++ii) {
     attrib_map[kAttribs[ii].name] = TestHelper::ConstructAttribute(
         kAttribs[ii].type,
         kAttribs[ii].size,
-        SH_PRECISION_MEDIUMP,
+        GL_MEDIUM_FLOAT,
         kAttribStaticUse,
         kAttribs[ii].name);
   }
   const char kAttribMatName[] = "matAttrib";
   attrib_map[kAttribMatName] = TestHelper::ConstructAttribute(
       GL_FLOAT_MAT2,
       1,
-      SH_PRECISION_MEDIUMP,
+      GL_MEDIUM_FLOAT,
       kAttribStaticUse,
       kAttribMatName);
   // Check we can create shader.
   Shader* vshader = shader_manager_.CreateShader(
       kVShaderClientId, kVShaderServiceId, GL_VERTEX_SHADER);
   Shader* fshader = shader_manager_.CreateShader(
       kFShaderClientId, kFShaderServiceId, GL_FRAGMENT_SHADER);
   // Check shader got created.
   ASSERT_TRUE(vshader != NULL && fshader != NULL);
   // Set Status
@@ skipping 420 matching lines @@
   static const GLuint kVertexShaderServiceId = 3;
   static const GLuint kFragmentShaderServiceId = 30;
 
   ProgramManagerWithCacheTest()
       : cache_(new MockProgramCache()),
         manager_(cache_.get(), kMaxVaryingVectors),
         vertex_shader_(NULL),
         fragment_shader_(NULL),
         program_(NULL) {
   }
-  virtual ~ProgramManagerWithCacheTest() {
+  ~ProgramManagerWithCacheTest() override {
     manager_.Destroy(false);
     shader_manager_.Destroy(false);
   }
 
  protected:
-  virtual void SetUp() {
+  void SetUp() override {
     GpuServiceTest::SetUp();
 
     vertex_shader_ = shader_manager_.CreateShader(
        kVertexShaderClientId, kVertexShaderServiceId, GL_VERTEX_SHADER);
     fragment_shader_ = shader_manager_.CreateShader(
        kFragmentShaderClientId, kFragmentShaderServiceId, GL_FRAGMENT_SHADER);
     ASSERT_TRUE(vertex_shader_ != NULL);
     ASSERT_TRUE(fragment_shader_ != NULL);
     vertex_shader_->set_source("lka asjf bjajsdfj");
     fragment_shader_->set_source("lka asjf a   fasgag 3rdsf3 bjajsdfj");
@@ skipping 183 matching lines @@
   SetExpectationsForProgramLoad(ProgramCache::PROGRAM_LOAD_SUCCESS);
   SetExpectationsForNotCachingProgram();
   SetExpectationsForProgramLoadSuccess();
 
   EXPECT_TRUE(program_->Link(NULL, NULL, NULL,
       Program::kCountOnlyStaticallyUsed, base::Bind(&ShaderCacheCb)));
 }
 
 }  // namespace gles2
 }  // namespace gpu