Clean up interfaces between Shader / ShaderTranslator / ANGLE side.

gpu/command_buffer/service/memory_program_cache_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/memory_program_cache.h"
 
 #include "base/bind.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/gpu_service_test.h"
 #include "gpu/command_buffer/service/shader_manager.h"
 #include "gpu/command_buffer/service/shader_translator.h"
+#include "gpu/command_buffer/service/test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_mock.h"
 
 using ::testing::_;
 using ::testing::ElementsAreArray;
 using ::testing::Invoke;
 using ::testing::SetArgPointee;
 using ::testing::SetArrayArgument;
 
@@ skipping 93 matching lines @@
     vertex_attrib_map["a"] = VariableInfo(1, 34, SH_PRECISION_LOWP, 0, "a");
     vertex_uniform_map["a"] = VariableInfo(0, 10, SH_PRECISION_MEDIUMP, 1, "a");
     vertex_uniform_map["b"] = VariableInfo(2, 3114, SH_PRECISION_HIGHP, 1, "b");
     vertex_varying_map["c"] = VariableInfo(3, 2, SH_PRECISION_HIGHP, 1, "c");
     fragment_attrib_map["jjjbb"] =
         VariableInfo(463, 1114, SH_PRECISION_MEDIUMP, 0, "jjjbb");
     fragment_uniform_map["k"] =
         VariableInfo(10, 34413, SH_PRECISION_MEDIUMP, 1, "k");
     fragment_varying_map["c"] = VariableInfo(3, 2, SH_PRECISION_HIGHP, 1, "c");
 
-    vertex_shader_->set_attrib_map(vertex_attrib_map);
-    vertex_shader_->set_uniform_map(vertex_uniform_map);
-    vertex_shader_->set_varying_map(vertex_varying_map);
-    fragment_shader_->set_attrib_map(vertex_attrib_map);
-    fragment_shader_->set_uniform_map(vertex_uniform_map);
-    fragment_shader_->set_varying_map(vertex_varying_map);
+    vertex_shader_->set_source("bbbalsldkdkdkd");
+    fragment_shader_->set_source("bbbal   sldkdkdkas 134 ad");
 
-    vertex_shader_->UpdateSource("bbbalsldkdkdkd");
-    fragment_shader_->UpdateSource("bbbal   sldkdkdkas 134 ad");
-
-    vertex_shader_->SetStatus(true, NULL, NULL);
-    fragment_shader_->SetStatus(true, NULL, NULL);
+    TestHelper::SetShaderStates(
+        gl_.get(), vertex_shader_, true, NULL, NULL,
+        &vertex_attrib_map, &vertex_uniform_map, &vertex_varying_map,
+        NULL);
+    TestHelper::SetShaderStates(
+        gl_.get(), fragment_shader_, true, NULL, NULL,
+        &fragment_attrib_map, &fragment_uniform_map, &fragment_varying_map,
+        NULL);
   }
 
   void SetExpectationsForSaveLinkedProgram(
       const GLint program_id,
       ProgramBinaryEmulator* emulator) const {
     EXPECT_CALL(*gl_.get(),
                 GetProgramiv(program_id, GL_PROGRAM_BINARY_LENGTH_OES, _))
         .WillOnce(SetArgPointee<2>(emulator->length()));
     EXPECT_CALL(*gl_.get(),
                 GetProgramBinary(program_id, emulator->length(), _, _, _))
@@ skipping 46 matching lines @@
   }
   ProgramBinaryEmulator emulator(kBinaryLength, kFormat, test_binary);
 
   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator);
   cache_->SaveLinkedProgram(kProgramId, vertex_shader_, NULL,
                             fragment_shader_, NULL, NULL,
                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
                                        base::Unretained(this)));
 
   EXPECT_EQ(ProgramCache::LINK_SUCCEEDED, cache_->GetLinkedProgramStatus(
-      *vertex_shader_->signature_source(),
+      vertex_shader_->signature_source(),
       NULL,
-      *fragment_shader_->signature_source(),
+      fragment_shader_->signature_source(),
       NULL,
       NULL));
   EXPECT_EQ(1, shader_cache_count());
 }
 
 TEST_F(MemoryProgramCacheTest, LoadProgram) {
   const GLenum kFormat = 1;
   const int kProgramId = 10;
   const int kBinaryLength = 20;
   char test_binary[kBinaryLength];
   for (int i = 0; i < kBinaryLength; ++i) {
     test_binary[i] = i;
   }
   ProgramBinaryEmulator emulator(kBinaryLength, kFormat, test_binary);
 
   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator);
   cache_->SaveLinkedProgram(kProgramId, vertex_shader_, NULL,
                             fragment_shader_, NULL, NULL,
                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
                                        base::Unretained(this)));
 
   EXPECT_EQ(ProgramCache::LINK_SUCCEEDED, cache_->GetLinkedProgramStatus(
-      *vertex_shader_->signature_source(),
+      vertex_shader_->signature_source(),
       NULL,
-      *fragment_shader_->signature_source(),
+      fragment_shader_->signature_source(),
       NULL,
       NULL));
   EXPECT_EQ(1, shader_cache_count());
 
   cache_->Clear();
 
   cache_->LoadProgram(shader_cache_shader());
   EXPECT_EQ(ProgramCache::LINK_SUCCEEDED, cache_->GetLinkedProgramStatus(
-      *vertex_shader_->signature_source(),
+      vertex_shader_->signature_source(),
       NULL,
-      *fragment_shader_->signature_source(),
+      fragment_shader_->signature_source(),
       NULL,
       NULL));
 }
 
 TEST_F(MemoryProgramCacheTest, CacheLoadMatchesSave) {
   const GLenum kFormat = 1;
   const int kProgramId = 10;
   const int kBinaryLength = 20;
   char test_binary[kBinaryLength];
   for (int i = 0; i < kBinaryLength; ++i) {
@@ skipping 141 matching lines @@
     test_binary[i] = i;
   }
   ProgramBinaryEmulator emulator(kBinaryLength, kFormat, test_binary);
 
   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator);
   cache_->SaveLinkedProgram(kProgramId, vertex_shader_, NULL,
                             fragment_shader_, NULL, NULL,
                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
                                        base::Unretained(this)));
 
-  const std::string vertex_orig_source =
-      *vertex_shader_->signature_source();
-  vertex_shader_->UpdateSource("different!");
-  vertex_shader_->SetStatus(true, NULL, NULL);
+  const std::string vertex_orig_source = vertex_shader_->signature_source();
+  vertex_shader_->set_source("different!");
+  TestHelper::SetShaderStates(gl_.get(), vertex_shader_, true);
   EXPECT_EQ(ProgramCache::PROGRAM_LOAD_FAILURE, cache_->LoadLinkedProgram(
       kProgramId,
       vertex_shader_,
       NULL,
       fragment_shader_,
       NULL,
       NULL,
       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
                  base::Unretained(this))));
 
-  vertex_shader_->UpdateSource(vertex_orig_source.c_str());
-  vertex_shader_->SetStatus(true, NULL, NULL);
-  fragment_shader_->UpdateSource("different!");
-  fragment_shader_->SetStatus(true, NULL, NULL);
+  vertex_shader_->set_source(vertex_orig_source);
+  TestHelper::SetShaderStates(gl_.get(), vertex_shader_, true);
+  fragment_shader_->set_source("different!");
+  TestHelper::SetShaderStates(gl_.get(), fragment_shader_, true);
   EXPECT_EQ(ProgramCache::PROGRAM_LOAD_FAILURE, cache_->LoadLinkedProgram(
       kProgramId,
       vertex_shader_,
       NULL,
       fragment_shader_,
       NULL,
       NULL,
       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
                  base::Unretained(this))));
 }
@@ skipping 55 matching lines @@
   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator1);
   cache_->SaveLinkedProgram(kProgramId, vertex_shader_, NULL,
                             fragment_shader_, NULL, NULL,
                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
                                        base::Unretained(this)));
 
   const int kEvictingProgramId = 11;
   const GLuint kEvictingBinaryLength = kCacheSizeBytes - kBinaryLength + 1;
 
   // save old source and modify for new program
-  const std::string old_source =
-      *fragment_shader_->signature_source();
-  fragment_shader_->UpdateSource("al sdfkjdk");
-  fragment_shader_->SetStatus(true, NULL, NULL);
+  const std::string& old_source = fragment_shader_->signature_source();
+  fragment_shader_->set_source("al sdfkjdk");
+  TestHelper::SetShaderStates(gl_.get(), fragment_shader_, true);
 
   scoped_ptr<char[]> bigTestBinary =
       scoped_ptr<char[]>(new char[kEvictingBinaryLength]);
   for (size_t i = 0; i < kEvictingBinaryLength; ++i) {
     bigTestBinary[i] = i % 250;
   }
   ProgramBinaryEmulator emulator2(kEvictingBinaryLength,
                                   kFormat,
                                   bigTestBinary.get());
 
   SetExpectationsForSaveLinkedProgram(kEvictingProgramId, &emulator2);
   cache_->SaveLinkedProgram(kEvictingProgramId,
                             vertex_shader_,
                             NULL,
                             fragment_shader_,
                             NULL,
                             NULL,
                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
                                        base::Unretained(this)));
 
   EXPECT_EQ(ProgramCache::LINK_SUCCEEDED, cache_->GetLinkedProgramStatus(
-      *vertex_shader_->signature_source(),
+      vertex_shader_->signature_source(),
       NULL,
-      *fragment_shader_->signature_source(),
+      fragment_shader_->signature_source(),
       NULL,
       NULL));
   EXPECT_EQ(ProgramCache::LINK_UNKNOWN, cache_->GetLinkedProgramStatus(
       old_source,
       NULL,
-      *fragment_shader_->signature_source(),
+      fragment_shader_->signature_source(),
       NULL,
       NULL));
 }
 
 TEST_F(MemoryProgramCacheTest, SaveCorrectProgram) {
   const GLenum kFormat = 1;
   const int kProgramId = 10;
   const int kBinaryLength = 20;
   char test_binary[kBinaryLength];
   for (int i = 0; i < kBinaryLength; ++i) {
     test_binary[i] = i;
   }
   ProgramBinaryEmulator emulator1(kBinaryLength, kFormat, test_binary);
 
-  vertex_shader_->UpdateSource("different!");
+  vertex_shader_->set_source("different!");
   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator1);
   cache_->SaveLinkedProgram(kProgramId, vertex_shader_, NULL,
                             fragment_shader_, NULL, NULL,
                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
                                        base::Unretained(this)));
 
   EXPECT_EQ(ProgramCache::LINK_SUCCEEDED, cache_->GetLinkedProgramStatus(
-      *vertex_shader_->signature_source(),
+      vertex_shader_->signature_source(),
       NULL,
-      *fragment_shader_->signature_source(),
+      fragment_shader_->signature_source(),
       NULL,
       NULL));
 }
 
 TEST_F(MemoryProgramCacheTest, LoadCorrectProgram) {
   const GLenum kFormat = 1;
   const int kProgramId = 10;
   const int kBinaryLength = 20;
   char test_binary[kBinaryLength];
   for (int i = 0; i < kBinaryLength; ++i) {
     test_binary[i] = i;
   }
   ProgramBinaryEmulator emulator(kBinaryLength, kFormat, test_binary);
 
   SetExpectationsForSaveLinkedProgram(kProgramId, &emulator);
   cache_->SaveLinkedProgram(kProgramId, vertex_shader_, NULL,
                             fragment_shader_, NULL, NULL,
                             base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
                                        base::Unretained(this)));
 
   EXPECT_EQ(ProgramCache::LINK_SUCCEEDED, cache_->GetLinkedProgramStatus(
-      *vertex_shader_->signature_source(),
+      vertex_shader_->signature_source(),
       NULL,
-      *fragment_shader_->signature_source(),
+      fragment_shader_->signature_source(),
       NULL,
       NULL));
 
   SetExpectationsForLoadLinkedProgram(kProgramId, &emulator);
 
-  fragment_shader_->UpdateSource("different!");
+  fragment_shader_->set_source("different!");
   EXPECT_EQ(ProgramCache::PROGRAM_LOAD_SUCCESS, cache_->LoadLinkedProgram(
       kProgramId,
       vertex_shader_,
       NULL,
       fragment_shader_,
       NULL,
       NULL,
       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
                  base::Unretained(this))));
 }
@@ skipping 33 matching lines @@
       NULL,
       fragment_shader_,
       NULL,
       NULL,
       base::Bind(&MemoryProgramCacheTest::ShaderCacheCb,
                  base::Unretained(this))));
 }
 
 }  // namespace gles2
 }  // namespace gpu