Swizzle Uniform Locations

gpu/command_buffer/service/program_manager_unittest.cc

 // Copyright (c) 2011 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/string_number_conversions.h"
@@ skipping 107 matching lines @@
       kClient1Id, kService1Id);
   ASSERT_TRUE(info1);
   EXPECT_EQ(kService1Id, info1->service_id());
   EXPECT_FALSE(info1->InUse());
   EXPECT_FALSE(info1->IsValid());
   EXPECT_FALSE(info1->IsDeleted());
   EXPECT_FALSE(info1->CanLink());
   EXPECT_TRUE(info1->log_info() == NULL);
 }
 
+TEST_F(ProgramManagerTest, SwizzleLocation) {
+  GLint power = 1;
+  for (GLint p = 0; p < 5; ++p, power *= 10) {
+    GLint limit = power * 20 + 1;
+    for (GLint ii = -limit; ii < limit; ii += power) {
+      GLint s = manager_.SwizzleLocation(ii);
+      EXPECT_EQ(ii, manager_.UnswizzleLocation(s));
+    }
+  }
+}
+
 class ProgramManagerWithShaderTest : public testing::Test {
  public:
   ProgramManagerWithShaderTest()
       : program_info_(NULL) {
   }
 
   ~ProgramManagerWithShaderTest() {
     manager_.Destroy(false);
     shader_manager_.Destroy(false);
   }
@@ skipping 703 matching lines @@
   EXPECT_TRUE(info2 == NULL);
   EXPECT_FALSE(vshader->InUse());
   EXPECT_FALSE(fshader->InUse());
 }
 
 TEST_F(ProgramManagerWithShaderTest, ProgramInfoGetProgramInfo) {
   CommonDecoder::Bucket bucket;
   const ProgramManager::ProgramInfo* program_info =
       manager_.GetProgramInfo(kClientProgramId);
   ASSERT_TRUE(program_info != NULL);
-  program_info->GetProgramInfo(&bucket);
+  program_info->GetProgramInfo(&manager_, &bucket);
   ProgramInfoHeader* header =
       bucket.GetDataAs<ProgramInfoHeader*>(0, sizeof(ProgramInfoHeader));
   ASSERT_TRUE(header != NULL);
   EXPECT_EQ(1u, header->link_status);
   EXPECT_EQ(arraysize(kAttribs), header->num_attribs);
   EXPECT_EQ(arraysize(kUniforms), header->num_uniforms);
   const ProgramInput* inputs = bucket.GetDataAs<const ProgramInput*>(
       sizeof(*header),
       sizeof(ProgramInput) * (header->num_attribs + header->num_uniforms));
   ASSERT_TRUE(inputs != NULL);
@@ skipping 16 matching lines @@
   }
   // TODO(gman): Don't assume these are in order.
   for (uint32 ii = 0; ii < header->num_uniforms; ++ii) {
     const UniformInfo& expected = kUniforms[ii];
     EXPECT_EQ(expected.size, input->size);
     EXPECT_EQ(expected.type, input->type);
     const int32* locations = bucket.GetDataAs<const int32*>(
         input->location_offset, sizeof(int32) * input->size);
     ASSERT_TRUE(locations != NULL);
     for (int32 jj = 0; jj < input->size; ++jj) {
-      EXPECT_EQ(expected.location + jj * 2, locations[jj]);
+      EXPECT_EQ(manager_.SwizzleLocation(expected.location + jj * 2),
+                locations[jj]);
     }
     const char* name_buf = bucket.GetDataAs<const char*>(
         input->name_offset, input->name_length);
     ASSERT_TRUE(name_buf != NULL);
     std::string name(name_buf, input->name_length);
     EXPECT_STREQ(expected.good_name, name.c_str());
     ++input;
   }
   EXPECT_EQ(header->num_attribs + header->num_uniforms,
             static_cast<uint32>(input - inputs));
 }
 
 }  // namespace gles2
 }  // namespace gpu