Update from https://crrev.com/311076

gpu/command_buffer/client/gles2_implementation_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.
 
 // Tests for GLES2Implementation.
 
 #include "gpu/command_buffer/client/gles2_implementation.h"
 
 #include <limits>
 
@@ skipping 2145 matching lines @@
   EXPECT_EQ(static_cast<GLenum>(GL_NO_ERROR), gl_->GetError());
 }
 
 static bool CheckRect(
     int width, int height, GLenum format, GLenum type, int alignment,
     bool flip_y, const uint8* r1, const uint8* r2) {
   uint32 size = 0;
   uint32 unpadded_row_size = 0;
   uint32 padded_row_size = 0;
   if (!GLES2Util::ComputeImageDataSizes(
-      width, height, format, type, alignment, &size, &unpadded_row_size,
+      width, height, 1, format, type, alignment, &size, &unpadded_row_size,
       &padded_row_size)) {
     return false;
   }
 
   int r2_stride = flip_y ?
       -static_cast<int>(padded_row_size) :
       static_cast<int>(padded_row_size);
   r2 = flip_y ? (r2 + (height - 1) * padded_row_size) : r2;
 
   for (int y = 0; y < height; ++y) {
@@ skipping 85 matching lines @@
   const GLenum kFormat = GL_RGB;
   const GLint kBorder = 0;
   const GLenum kType = GL_UNSIGNED_BYTE;
   const GLint kPixelStoreUnpackAlignment = 4;
   const GLsizei kWidth = 3;
 
   uint32 size = 0;
   uint32 unpadded_row_size = 0;
   uint32 padded_row_size = 0;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
-      kWidth, 2, kFormat, kType, kPixelStoreUnpackAlignment,
+      kWidth, 2, 1, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, &unpadded_row_size, &padded_row_size));
   const GLsizei kHeight = (MaxTransferBufferSize() / padded_row_size) * 2;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
-      kWidth, kHeight, kFormat, kType, kPixelStoreUnpackAlignment,
+      kWidth, kHeight, 1, kFormat, kType, kPixelStoreUnpackAlignment,
       &size, NULL, NULL));
   uint32 half_size = 0;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
-      kWidth, kHeight / 2, kFormat, kType, kPixelStoreUnpackAlignment,
+      kWidth, kHeight / 2, 1, kFormat, kType, kPixelStoreUnpackAlignment,
       &half_size, NULL, NULL));
 
   scoped_ptr<uint8[]> pixels(new uint8[size]);
   for (uint32 ii = 0; ii < size; ++ii) {
     pixels[ii] = static_cast<uint8>(ii);
   }
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(half_size);
   ExpectedMemoryInfo mem2 = GetExpectedMemory(half_size);
 
@@ skipping 80 matching lines @@
     cmds::TexImage2D tex_image_2d;
     cmds::PixelStorei pixel_store_i2;
     cmds::TexSubImage2D tex_sub_image_2d1;
     cmd::SetToken set_token1;
     cmds::TexSubImage2D tex_sub_image_2d2;
     cmd::SetToken set_token2;
   };
 
   uint32 sub_2_high_size = 0;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
-      kSubImageWidth, 2, kFormat, kType, kPixelStoreUnpackAlignment,
+      kSubImageWidth, 2, 1, kFormat, kType, kPixelStoreUnpackAlignment,
       &sub_2_high_size, NULL, NULL));
 
   ExpectedMemoryInfo mem1 = GetExpectedMemory(sub_2_high_size);
   ExpectedMemoryInfo mem2 = GetExpectedMemory(sub_2_high_size);
 
   Cmds expected;
   expected.pixel_store_i1.Init(GL_UNPACK_ALIGNMENT, kPixelStoreUnpackAlignment);
   expected.tex_image_2d.Init(
       kTarget, kLevel, kFormat, kTextureWidth, kTextureHeight, kFormat,
       kType, 0, 0);
@@ skipping 61 matching lines @@
 
   struct  {
     cmds::PixelStorei pixel_store_i;
     cmds::PixelStorei pixel_store_i2;
     cmds::TexImage2D tex_image_2d;
     cmds::TexSubImage2D tex_sub_image_2d;
   } texSubImageExpected;
 
   uint32 src_size;
   ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
-      kSrcWidth, kSrcSubImageY1, kFormat, kType, 8, &src_size, NULL, NULL));
+      kSrcWidth, kSrcSubImageY1, 1, kFormat, kType, 8, &src_size, NULL, NULL));
   scoped_ptr<uint8[]> src_pixels;
   src_pixels.reset(new uint8[src_size]);
   for (size_t i = 0; i < src_size; ++i) {
     src_pixels[i] = static_cast<int8>(i);
   }
 
   for (int sub = 0; sub < 2; ++sub) {
     for (int flip_y = 0; flip_y < 2; ++flip_y) {
       for (size_t a = 0; a < arraysize(unpack_alignments); ++a) {
         GLint alignment = unpack_alignments[a];
         uint32 size;
         uint32 unpadded_row_size;
         uint32 padded_row_size;
         ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
-            kSrcSubImageWidth, kSrcSubImageHeight, kFormat, kType, alignment,
+            kSrcSubImageWidth, kSrcSubImageHeight, 1, kFormat, kType, alignment,
             &size, &unpadded_row_size, &padded_row_size));
         ASSERT_TRUE(size <= MaxTransferBufferSize());
         ExpectedMemoryInfo mem = GetExpectedMemory(size);
 
         const void* commands = GetPut();
         gl_->PixelStorei(GL_UNPACK_ALIGNMENT, alignment);
         gl_->PixelStorei(GL_UNPACK_ROW_LENGTH_EXT, kSrcWidth);
         gl_->PixelStorei(GL_UNPACK_SKIP_PIXELS_EXT, kSrcSubImageX0);
         gl_->PixelStorei(GL_UNPACK_SKIP_ROWS_EXT, kSrcSubImageY0);
         gl_->PixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, flip_y);
@@ skipping 130 matching lines @@
 
   // Changing border to invalid border should make the call fail at the client
   // checks.
   gl_->CompressedTexImage2D(
       kTarget, kLevel, kCompressedFormat, kWidth, kHeight, kInvalidBorder,
       arraysize(pixels), pixels);
   EXPECT_TRUE(NoCommandsWritten());
   EXPECT_EQ(GL_INVALID_VALUE, CheckError());
 }
 
+TEST_F(GLES2ImplementationTest, TexImage3DSingleCommand) {
+  struct Cmds {
+    cmds::TexImage3D tex_image_3d;
+  };
+  const GLenum kTarget = GL_TEXTURE_3D;
+  const GLint kLevel = 0;
+  const GLint kBorder = 0;
+  const GLenum kFormat = GL_RGB;
+  const GLenum kType = GL_UNSIGNED_BYTE;
+  const GLint kPixelStoreUnpackAlignment = 4;
+  const GLsizei kWidth = 3;
+  const GLsizei kDepth = 2;
+
+  uint32 size = 0;
+  uint32 unpadded_row_size = 0;
+  uint32 padded_row_size = 0;
+  ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
+      kWidth, 2, kDepth, kFormat, kType, kPixelStoreUnpackAlignment,
+      &size, &unpadded_row_size, &padded_row_size));
+  // Makes sure we can just send over the data in one command.
+  const GLsizei kHeight = MaxTransferBufferSize() / padded_row_size / kDepth;
+
+  scoped_ptr<uint8[]> pixels(new uint8[size]);
+  for (uint32 ii = 0; ii < size; ++ii) {
+    pixels[ii] = static_cast<uint8>(ii);
+  }
+
+  ExpectedMemoryInfo mem = GetExpectedMemory(size);
+
+  Cmds expected;
+  expected.tex_image_3d.Init(
+      kTarget, kLevel, kFormat, kWidth, kHeight, kDepth,
+      kFormat, kType, mem.id, mem.offset);
+
+  gl_->TexImage3D(
+      kTarget, kLevel, kFormat, kWidth, kHeight, kDepth, kBorder,
+      kFormat, kType, pixels.get());
+
+  EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
+  EXPECT_TRUE(CheckRect(
+      kWidth, kHeight * kDepth, kFormat, kType, kPixelStoreUnpackAlignment,
+      false, reinterpret_cast<uint8*>(pixels.get()), mem.ptr));
+}
+
+TEST_F(GLES2ImplementationTest, TexImage3DViaTexSubImage3D) {
+  struct Cmds {
+    cmds::TexImage3D tex_image_3d;
+    cmds::TexSubImage3D tex_sub_image_3d1;
+    cmd::SetToken set_token;
+    cmds::TexSubImage3D tex_sub_image_3d2;
+  };
+  const GLenum kTarget = GL_TEXTURE_3D;
+  const GLint kLevel = 0;
+  const GLint kBorder = 0;
+  const GLenum kFormat = GL_RGB;
+  const GLenum kType = GL_UNSIGNED_BYTE;
+  const GLint kPixelStoreUnpackAlignment = 4;
+  const GLsizei kWidth = 3;
+
+  uint32 size = 0;
+  uint32 unpadded_row_size = 0;
+  uint32 padded_row_size = 0;
+  ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
+      kWidth, 2, 1, kFormat, kType, kPixelStoreUnpackAlignment,
+      &size, &unpadded_row_size, &padded_row_size));
+  // Makes sure the data is more than one command can hold.
+  const GLsizei kHeight = MaxTransferBufferSize() / padded_row_size + 3;
+  ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
+      kWidth, kHeight, 1, kFormat, kType, kPixelStoreUnpackAlignment,
+      &size, NULL, NULL));
+  uint32 first_size = padded_row_size * (kHeight - 3);
+  uint32 second_size =
+      padded_row_size * 3 - (padded_row_size - unpadded_row_size);
+  EXPECT_EQ(size, first_size + second_size);
+  ExpectedMemoryInfo mem1 = GetExpectedMemory(first_size);
+  ExpectedMemoryInfo mem2 = GetExpectedMemory(second_size);
+  scoped_ptr<uint8[]> pixels(new uint8[size]);
+  for (uint32 ii = 0; ii < size; ++ii) {
+    pixels[ii] = static_cast<uint8>(ii);
+  }
+
+  Cmds expected;
+  expected.tex_image_3d.Init(
+      kTarget, kLevel, kFormat, kWidth, kHeight, 1, kFormat, kType, 0, 0);
+  expected.tex_sub_image_3d1.Init(
+      kTarget, kLevel, 0, 0, 0, kWidth, kHeight - 3, 1, kFormat, kType,
+      mem1.id, mem1.offset, GL_TRUE);
+  expected.tex_sub_image_3d2.Init(
+      kTarget, kLevel, 0, kHeight - 3, 0, kWidth, 3, 1, kFormat, kType,
+      mem2.id, mem2.offset, GL_TRUE);
+  expected.set_token.Init(GetNextToken());
+
+  gl_->TexImage3D(
+      kTarget, kLevel, kFormat, kWidth, kHeight, 1, kBorder,
+      kFormat, kType, pixels.get());
+  EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
+}
+
+// Test TexSubImage3D with 4 writes
+TEST_F(GLES2ImplementationTest, TexSubImage3D4Writes) {
+  struct Cmds {
+    cmds::TexSubImage3D tex_sub_image_3d1_1;
+    cmd::SetToken set_token1;
+    cmds::TexSubImage3D tex_sub_image_3d1_2;
+    cmd::SetToken set_token2;
+    cmds::TexSubImage3D tex_sub_image_3d2_1;
+    cmd::SetToken set_token3;
+    cmds::TexSubImage3D tex_sub_image_3d2_2;
+  };
+  const GLenum kTarget = GL_TEXTURE_3D;
+  const GLint kLevel = 0;
+  const GLint kXOffset = 0;
+  const GLint kYOffset = 0;
+  const GLint kZOffset = 0;
+  const GLenum kFormat = GL_RGB;
+  const GLenum kType = GL_UNSIGNED_BYTE;
+  const GLint kPixelStoreUnpackAlignment = 4;
+  const GLsizei kWidth = 3;
+  const GLsizei kDepth = 2;
+
+  uint32 size = 0;
+  uint32 unpadded_row_size = 0;
+  uint32 padded_row_size = 0;
+  ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
+      kWidth, 2, 1, kFormat, kType, kPixelStoreUnpackAlignment,
+      &size, &unpadded_row_size, &padded_row_size));
+  const GLsizei kHeight = MaxTransferBufferSize() / padded_row_size + 2;
+  ASSERT_TRUE(GLES2Util::ComputeImageDataSizes(
+      kWidth, kHeight, kDepth, kFormat, kType, kPixelStoreUnpackAlignment,
+      &size, NULL, NULL));
+  uint32 first_size = (kHeight - 2) * padded_row_size;
+  uint32 second_size = 2 * padded_row_size;
+  uint32 third_size = first_size;
+  uint32 fourth_size = second_size - (padded_row_size - unpadded_row_size);
+  EXPECT_EQ(size, first_size + second_size + third_size + fourth_size);
+
+  scoped_ptr<uint8[]> pixels(new uint8[size]);
+  for (uint32 ii = 0; ii < size; ++ii) {
+    pixels[ii] = static_cast<uint8>(ii);
+  }
+
+  ExpectedMemoryInfo mem1_1 = GetExpectedMemory(first_size);
+  ExpectedMemoryInfo mem1_2 = GetExpectedMemory(second_size);
+  ExpectedMemoryInfo mem2_1 = GetExpectedMemory(third_size);
+  ExpectedMemoryInfo mem2_2 = GetExpectedMemory(fourth_size);
+
+  Cmds expected;
+  expected.tex_sub_image_3d1_1.Init(
+      kTarget, kLevel, kXOffset, kYOffset, kZOffset,
+      kWidth, kHeight - 2, 1, kFormat, kType,
+      mem1_1.id, mem1_1.offset, GL_FALSE);
+  expected.tex_sub_image_3d1_2.Init(
+      kTarget, kLevel, kXOffset, kYOffset + kHeight - 2, kZOffset,
+      kWidth, 2, 1, kFormat, kType, mem1_2.id, mem1_2.offset, GL_FALSE);
+  expected.tex_sub_image_3d2_1.Init(
+      kTarget, kLevel, kXOffset, kYOffset, kZOffset + 1,
+      kWidth, kHeight - 2, 1, kFormat, kType,
+      mem2_1.id, mem2_1.offset, GL_FALSE);
+  expected.tex_sub_image_3d2_2.Init(
+      kTarget, kLevel, kXOffset, kYOffset + kHeight - 2, kZOffset + 1,
+      kWidth, 2, 1, kFormat, kType, mem2_2.id, mem2_2.offset, GL_FALSE);
+  expected.set_token1.Init(GetNextToken());
+  expected.set_token2.Init(GetNextToken());
+  expected.set_token3.Init(GetNextToken());
+
+  gl_->TexSubImage3D(
+      kTarget, kLevel, kXOffset, kYOffset, kZOffset, kWidth, kHeight, kDepth,
+      kFormat, kType, pixels.get());
+
+  EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
+  uint32 offset_to_last = first_size + second_size + third_size;
+  EXPECT_TRUE(CheckRect(
+      kWidth, 2, kFormat, kType, kPixelStoreUnpackAlignment, false,
+      reinterpret_cast<uint8*>(pixels.get()) + offset_to_last, mem2_2.ptr));
+}
 
 // Binds can not be cached with bind_generates_resource = false because
 // our id might not be valid. More specifically if you bind on contextA then
 // delete on contextB the resource is still bound on contextA but GetInterger
 // won't return an id.
 TEST_F(GLES2ImplementationStrictSharedTest, BindsNotCached) {
   struct PNameValue {
     GLenum pname;
     GLint expected;
   };
@@ skipping 620 matching lines @@
   EXPECT_EQ(GL_NO_ERROR, CheckError());
 
   // VertexAttribPointer: offset
   gl_->VertexAttribPointer(
       kAttribIndex, 1, GL_FLOAT, GL_FALSE, kStride,
       reinterpret_cast<void*>(offset));
   EXPECT_EQ(GL_INVALID_OPERATION, CheckError());
   EXPECT_STREQ(kOffsetOverflowMessage, GetLastError().c_str());
 }
 
+TEST_F(GLES2ImplementationTest, TraceBeginCHROMIUM) {
+  const uint32 kCategoryBucketId = GLES2Implementation::kResultBucketId;
+  const uint32 kNameBucketId = GLES2Implementation::kResultBucketId + 1;
+  const std::string category_name = "test category";
+  const std::string trace_name = "test trace";
+  const size_t kPaddedString1Size =
+      transfer_buffer_->RoundToAlignment(category_name.size() + 1);
+  const size_t kPaddedString2Size =
+      transfer_buffer_->RoundToAlignment(trace_name.size() + 1);
+
+  gl_->TraceBeginCHROMIUM(category_name.c_str(), trace_name.c_str());
+  EXPECT_EQ(GL_NO_ERROR, CheckError());
+
+  struct Cmds {
+    cmd::SetBucketSize category_size1;
+    cmd::SetBucketData category_data;
+    cmd::SetToken set_token1;
+    cmd::SetBucketSize name_size1;
+    cmd::SetBucketData name_data;
+    cmd::SetToken set_token2;
+    cmds::TraceBeginCHROMIUM trace_call_begin;
+    cmd::SetBucketSize category_size2;
+    cmd::SetBucketSize name_size2;
+  };
+
+  ExpectedMemoryInfo mem1 = GetExpectedMemory(kPaddedString1Size);
+  ExpectedMemoryInfo mem2 = GetExpectedMemory(kPaddedString2Size);
+
+  ASSERT_STREQ(category_name.c_str(), reinterpret_cast<char*>(mem1.ptr));
+  ASSERT_STREQ(trace_name.c_str(), reinterpret_cast<char*>(mem2.ptr));
+
+  Cmds expected;
+  expected.category_size1.Init(kCategoryBucketId, category_name.size() + 1);
+  expected.category_data.Init(
+      kCategoryBucketId, 0, category_name.size() + 1, mem1.id, mem1.offset);
+  expected.set_token1.Init(GetNextToken());
+  expected.name_size1.Init(kNameBucketId, trace_name.size() + 1);
+  expected.name_data.Init(
+      kNameBucketId, 0, trace_name.size() + 1, mem2.id, mem2.offset);
+  expected.set_token2.Init(GetNextToken());
+  expected.trace_call_begin.Init(kCategoryBucketId, kNameBucketId);
+  expected.category_size2.Init(kCategoryBucketId, 0);
+  expected.name_size2.Init(kNameBucketId, 0);
+
+  EXPECT_EQ(0, memcmp(&expected, commands_, sizeof(expected)));
+}
+
+TEST_F(GLES2ImplementationTest, AllowNestedTracesCHROMIUM) {
+  const std::string category1_name = "test category 1";
+  const std::string trace1_name = "test trace 1";
+  const std::string category2_name = "test category 2";
+  const std::string trace2_name = "test trace 2";
+
+  gl_->TraceBeginCHROMIUM(category1_name.c_str(), trace1_name.c_str());
+  EXPECT_EQ(GL_NO_ERROR, CheckError());
+
+  gl_->TraceBeginCHROMIUM(category2_name.c_str(), trace2_name.c_str());
+  EXPECT_EQ(GL_NO_ERROR, CheckError());
+
+  gl_->TraceEndCHROMIUM();
+  EXPECT_EQ(GL_NO_ERROR, CheckError());
+
+  gl_->TraceEndCHROMIUM();
+  EXPECT_EQ(GL_NO_ERROR, CheckError());
+
+  // No more corresponding begin tracer marker should error.
+  gl_->TraceEndCHROMIUM();
+  EXPECT_EQ(GL_INVALID_OPERATION, CheckError());
+}
+
 TEST_F(GLES2ImplementationManualInitTest, LoseContextOnOOM) {
   ContextInitOptions init_options;
   init_options.lose_context_when_out_of_memory = true;
   ASSERT_TRUE(Initialize(init_options));
 
   struct Cmds {
     cmds::LoseContextCHROMIUM cmd;
   };
 
   GLsizei max = std::numeric_limits<GLsizei>::max();
@@ skipping 39 matching lines @@
 TEST_F(GLES2ImplementationManualInitTest, FailInitOnTransferBufferFail) {
   ContextInitOptions init_options;
   init_options.transfer_buffer_initialize_fail = true;
   EXPECT_FALSE(Initialize(init_options));
 }
 
 #include "gpu/command_buffer/client/gles2_implementation_unittest_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu