gpu/command_buffer/service/gles2_cmd_decoder_unittest_async_pixel.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/strings/string_number_conversions.h"
   9 #include "gpu/command_buffer/common/gles2_cmd_format.h"
  10 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
  11 #include "gpu/command_buffer/common/id_allocator.h"
  12 #include "gpu/command_buffer/service/async_pixel_transfer_delegate_mock.h"
  13 #include "gpu/command_buffer/service/async_pixel_transfer_manager.h"
  14 #include "gpu/command_buffer/service/async_pixel_transfer_manager_mock.h"
  15 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
  16 #include "gpu/command_buffer/service/context_group.h"
  17 #include "gpu/command_buffer/service/context_state.h"
  18 #include "gpu/command_buffer/service/gl_surface_mock.h"
  19 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest.h"
  20
  21 #include "gpu/command_buffer/service/gpu_switches.h"
  22 #include "gpu/command_buffer/service/image_manager.h"
  23 #include "gpu/command_buffer/service/mailbox_manager.h"
  24 #include "gpu/command_buffer/service/mocks.h"
  25 #include "gpu/command_buffer/service/program_manager.h"
  26 #include "gpu/command_buffer/service/test_helper.h"
  27 #include "testing/gtest/include/gtest/gtest.h"
  28 #include "ui/gl/gl_implementation.h"
  29 #include "ui/gl/gl_mock.h"
  30 #include "ui/gl/gl_surface_stub.h"
  31
  32 #if !defined(GL_DEPTH24_STENCIL8)
  33 #define GL_DEPTH24_STENCIL8 0x88F0
  34 #endif
  35
  36 using ::gfx::MockGLInterface;
  37 using ::testing::_;
  38 using ::testing::DoAll;
  39 using ::testing::InSequence;
  40 using ::testing::Invoke;
  41 using ::testing::MatcherCast;
  42 using ::testing::Mock;
  43 using ::testing::Pointee;
  44 using ::testing::Return;
  45 using ::testing::SaveArg;
  46 using ::testing::SetArrayArgument;
  47 using ::testing::SetArgumentPointee;
  48 using ::testing::SetArgPointee;
  49 using ::testing::StrEq;
  50 using ::testing::StrictMock;
  51
  52 namespace gpu {
  53 namespace gles2 {
  54
  55 using namespace cmds;
  56
  57 TEST_P(GLES2DecoderManualInitTest, AsyncPixelTransfers) {
  58   InitState init;
  59   init.extensions = "GL_CHROMIUM_async_pixel_transfers";
  60   init.gl_version = "3.0";
  61   init.bind_generates_resource = true;
  62   InitDecoder(init);
  63
  64   // Set up the texture.
  65   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
  66   TextureRef* texture_ref = GetTexture(client_texture_id_);
  67   Texture* texture = texture_ref->texture();
  68
  69   // Set a mock Async delegate
  70   StrictMock<gpu::MockAsyncPixelTransferManager>* manager =
  71       new StrictMock<gpu::MockAsyncPixelTransferManager>;
  72   manager->Initialize(group().texture_manager());
  73   decoder_->SetAsyncPixelTransferManagerForTest(manager);
  74   StrictMock<gpu::MockAsyncPixelTransferDelegate>* delegate = NULL;
  75
  76   // Tex(Sub)Image2D upload commands.
  77   AsyncTexImage2DCHROMIUM teximage_cmd;
  78   teximage_cmd.Init(GL_TEXTURE_2D,
  79                     0,
  80                     GL_RGBA,
  81                     8,
  82                     8,
  83                     GL_RGBA,
  84                     GL_UNSIGNED_BYTE,
  85                     kSharedMemoryId,
  86                     kSharedMemoryOffset,
  87                     0,
  88                     0,
  89                     0);
  90   AsyncTexSubImage2DCHROMIUM texsubimage_cmd;
  91   texsubimage_cmd.Init(GL_TEXTURE_2D,
  92                        0,
  93                        0,
  94                        0,
  95                        8,
  96                        8,
  97                        GL_RGBA,
  98                        GL_UNSIGNED_BYTE,
  99                        kSharedMemoryId,
 100                        kSharedMemoryOffset,
 101                        0,
 102                        0,
 103                        0);
 104   WaitAsyncTexImage2DCHROMIUM wait_cmd;
 105   wait_cmd.Init(GL_TEXTURE_2D);
 106   WaitAllAsyncTexImage2DCHROMIUM wait_all_cmd;
 107   wait_all_cmd.Init();
 108
 109   // No transfer state exists initially.
 110   EXPECT_FALSE(
 111       decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
 112           texture_ref));
 113
 114   base::Closure bind_callback;
 115
 116   // AsyncTexImage2D
 117   {
 118     // Create transfer state since it doesn't exist.
 119     EXPECT_EQ(texture_ref->num_observers(), 0);
 120     EXPECT_CALL(*manager, CreatePixelTransferDelegateImpl(texture_ref, _))
 121         .WillOnce(Return(
 122             delegate = new StrictMock<gpu::MockAsyncPixelTransferDelegate>))
 123         .RetiresOnSaturation();
 124     EXPECT_CALL(*delegate, AsyncTexImage2D(_, _, _))
 125         .WillOnce(SaveArg<2>(&bind_callback))
 126         .RetiresOnSaturation();
 127     // Command succeeds.
 128     EXPECT_EQ(error::kNoError, ExecuteCmd(teximage_cmd));
 129     EXPECT_EQ(GL_NO_ERROR, GetGLError());
 130     EXPECT_EQ(
 131         delegate,
 132         decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
 133             texture_ref));
 134     EXPECT_TRUE(texture->IsImmutable());
 135     // The texture is safe but the level has not been defined yet.
 136     EXPECT_TRUE(texture->SafeToRenderFrom());
 137     GLsizei width, height;
 138     EXPECT_FALSE(texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
 139     EXPECT_EQ(texture_ref->num_observers(), 1);
 140   }
 141   {
 142     // Async redefinitions are not allowed!
 143     // Command fails.
 144     EXPECT_EQ(error::kNoError, ExecuteCmd(teximage_cmd));
 145     EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 146     EXPECT_EQ(
 147         delegate,
 148         decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
 149             texture_ref));
 150     EXPECT_TRUE(texture->IsImmutable());
 151     EXPECT_TRUE(texture->SafeToRenderFrom());
 152   }
 153
 154   // Binding/defining of the async transfer
 155   {
 156     // TODO(epenner): We should check that the manager gets the
 157     // BindCompletedAsyncTransfers() call, which is required to
 158     // guarantee the delegate calls the bind callback.
 159
 160     // Simulate the bind callback from the delegate.
 161     bind_callback.Run();
 162
 163     // After the bind callback is run, the texture is safe,
 164     // and has the right size etc.
 165     EXPECT_TRUE(texture->SafeToRenderFrom());
 166     GLsizei width, height;
 167     EXPECT_TRUE(texture->GetLevelSize(GL_TEXTURE_2D, 0, &width, &height));
 168     EXPECT_EQ(width, 8);
 169     EXPECT_EQ(height, 8);
 170   }
 171
 172   // AsyncTexSubImage2D
 173   EXPECT_CALL(*delegate, Destroy()).RetiresOnSaturation();
 174   decoder_->GetAsyncPixelTransferManager()->ClearPixelTransferDelegateForTest(
 175       texture_ref);
 176   EXPECT_EQ(texture_ref->num_observers(), 0);
 177   texture->SetImmutable(false);
 178   {
 179     // Create transfer state since it doesn't exist.
 180     EXPECT_CALL(*manager, CreatePixelTransferDelegateImpl(texture_ref, _))
 181         .WillOnce(Return(
 182             delegate = new StrictMock<gpu::MockAsyncPixelTransferDelegate>))
 183         .RetiresOnSaturation();
 184     EXPECT_CALL(*delegate, AsyncTexSubImage2D(_, _)).RetiresOnSaturation();
 185     // Command succeeds.
 186     EXPECT_EQ(error::kNoError, ExecuteCmd(texsubimage_cmd));
 187     EXPECT_EQ(GL_NO_ERROR, GetGLError());
 188     EXPECT_EQ(
 189         delegate,
 190         decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
 191             texture_ref));
 192     EXPECT_TRUE(texture->IsImmutable());
 193     EXPECT_TRUE(texture->SafeToRenderFrom());
 194   }
 195   {
 196     // No transfer is in progress.
 197     EXPECT_CALL(*delegate, TransferIsInProgress())
 198         .WillOnce(Return(false))  // texSubImage validation
 199         .WillOnce(Return(false))  // async validation
 200         .RetiresOnSaturation();
 201     EXPECT_CALL(*delegate, AsyncTexSubImage2D(_, _)).RetiresOnSaturation();
 202     // Command succeeds.
 203     EXPECT_EQ(error::kNoError, ExecuteCmd(texsubimage_cmd));
 204     EXPECT_EQ(GL_NO_ERROR, GetGLError());
 205     EXPECT_EQ(
 206         delegate,
 207         decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
 208             texture_ref));
 209     EXPECT_TRUE(texture->IsImmutable());
 210     EXPECT_TRUE(texture->SafeToRenderFrom());
 211   }
 212   {
 213     // A transfer is still in progress!
 214     EXPECT_CALL(*delegate, TransferIsInProgress())
 215         .WillOnce(Return(true))
 216         .RetiresOnSaturation();
 217     // No async call, command fails.
 218     EXPECT_EQ(error::kNoError, ExecuteCmd(texsubimage_cmd));
 219     EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 220     EXPECT_EQ(
 221         delegate,
 222         decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
 223             texture_ref));
 224     EXPECT_TRUE(texture->IsImmutable());
 225     EXPECT_TRUE(texture->SafeToRenderFrom());
 226   }
 227
 228   // Delete delegate on DeleteTexture.
 229   {
 230     EXPECT_EQ(texture_ref->num_observers(), 1);
 231     EXPECT_CALL(*delegate, Destroy()).RetiresOnSaturation();
 232     DoDeleteTexture(client_texture_id_, kServiceTextureId);
 233     EXPECT_FALSE(
 234         decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
 235             texture_ref));
 236     texture = NULL;
 237     texture_ref = NULL;
 238     delegate = NULL;
 239   }
 240
 241   // WaitAsyncTexImage2D
 242   {
 243     // Get a fresh texture since the existing texture cannot be respecified
 244     // asynchronously and AsyncTexSubImage2D does not involve binding.
 245     EXPECT_CALL(*gl_, GenTextures(1, _))
 246         .WillOnce(SetArgumentPointee<1>(kServiceTextureId));
 247     DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 248     texture_ref = GetTexture(client_texture_id_);
 249     texture = texture_ref->texture();
 250     texture->SetImmutable(false);
 251     // Create transfer state since it doesn't exist.
 252     EXPECT_CALL(*manager, CreatePixelTransferDelegateImpl(texture_ref, _))
 253         .WillOnce(Return(
 254             delegate = new StrictMock<gpu::MockAsyncPixelTransferDelegate>))
 255         .RetiresOnSaturation();
 256     EXPECT_CALL(*delegate, AsyncTexImage2D(_, _, _)).RetiresOnSaturation();
 257     // Start async transfer.
 258     EXPECT_EQ(error::kNoError, ExecuteCmd(teximage_cmd));
 259     EXPECT_EQ(GL_NO_ERROR, GetGLError());
 260     EXPECT_EQ(
 261         delegate,
 262         decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
 263             texture_ref));
 264
 265     EXPECT_TRUE(texture->IsImmutable());
 266     // Wait for completion.
 267     EXPECT_CALL(*delegate, WaitForTransferCompletion());
 268     EXPECT_CALL(*manager, BindCompletedAsyncTransfers());
 269     EXPECT_EQ(error::kNoError, ExecuteCmd(wait_cmd));
 270     EXPECT_EQ(GL_NO_ERROR, GetGLError());
 271   }
 272
 273   // WaitAllAsyncTexImage2D
 274   EXPECT_CALL(*delegate, Destroy()).RetiresOnSaturation();
 275   DoDeleteTexture(client_texture_id_, kServiceTextureId);
 276   EXPECT_FALSE(
 277       decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
 278           texture_ref));
 279   texture = NULL;
 280   texture_ref = NULL;
 281   delegate = NULL;
 282   {
 283     // Get a fresh texture since the existing texture cannot be respecified
 284     // asynchronously and AsyncTexSubImage2D does not involve binding.
 285     EXPECT_CALL(*gl_, GenTextures(1, _))
 286         .WillOnce(SetArgumentPointee<1>(kServiceTextureId));
 287     DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 288     texture_ref = GetTexture(client_texture_id_);
 289     texture = texture_ref->texture();
 290     texture->SetImmutable(false);
 291     // Create transfer state since it doesn't exist.
 292     EXPECT_CALL(*manager, CreatePixelTransferDelegateImpl(texture_ref, _))
 293         .WillOnce(Return(
 294             delegate = new StrictMock<gpu::MockAsyncPixelTransferDelegate>))
 295         .RetiresOnSaturation();
 296     EXPECT_CALL(*delegate, AsyncTexImage2D(_, _, _)).RetiresOnSaturation();
 297     // Start async transfer.
 298     EXPECT_EQ(error::kNoError, ExecuteCmd(teximage_cmd));
 299     EXPECT_EQ(GL_NO_ERROR, GetGLError());
 300     EXPECT_EQ(
 301         delegate,
 302         decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
 303             texture_ref));
 304
 305     EXPECT_TRUE(texture->IsImmutable());
 306     // Wait for completion of all uploads.
 307     EXPECT_CALL(*manager, WaitAllAsyncTexImage2D()).RetiresOnSaturation();
 308     EXPECT_CALL(*manager, BindCompletedAsyncTransfers());
 309     EXPECT_EQ(error::kNoError, ExecuteCmd(wait_all_cmd));
 310     EXPECT_EQ(GL_NO_ERROR, GetGLError());
 311   }
 312
 313   // Remove PixelTransferManager before the decoder destroys.
 314   EXPECT_CALL(*delegate, Destroy()).RetiresOnSaturation();
 315   decoder_->ResetAsyncPixelTransferManagerForTest();
 316   manager = NULL;
 317 }
 318
 319 TEST_P(GLES2DecoderManualInitTest, AsyncPixelTransferManager) {
 320   InitState init;
 321   init.extensions = "GL_CHROMIUM_async_pixel_transfers";
 322   init.gl_version = "3.0";
 323   init.bind_generates_resource = true;
 324   InitDecoder(init);
 325
 326   // Set up the texture.
 327   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 328   TextureRef* texture_ref = GetTexture(client_texture_id_);
 329
 330   // Set a mock Async delegate.
 331   StrictMock<gpu::MockAsyncPixelTransferManager>* manager =
 332       new StrictMock<gpu::MockAsyncPixelTransferManager>;
 333   manager->Initialize(group().texture_manager());
 334   decoder_->SetAsyncPixelTransferManagerForTest(manager);
 335   StrictMock<gpu::MockAsyncPixelTransferDelegate>* delegate = NULL;
 336
 337   AsyncTexImage2DCHROMIUM teximage_cmd;
 338   teximage_cmd.Init(GL_TEXTURE_2D,
 339                     0,
 340                     GL_RGBA,
 341                     8,
 342                     8,
 343                     GL_RGBA,
 344                     GL_UNSIGNED_BYTE,
 345                     kSharedMemoryId,
 346                     kSharedMemoryOffset,
 347                     0,
 348                     0,
 349                     0);
 350
 351   // No transfer delegate exists initially.
 352   EXPECT_FALSE(
 353       decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
 354           texture_ref));
 355
 356   // Create delegate on AsyncTexImage2D.
 357   {
 358     EXPECT_CALL(*manager, CreatePixelTransferDelegateImpl(texture_ref, _))
 359         .WillOnce(Return(
 360             delegate = new StrictMock<gpu::MockAsyncPixelTransferDelegate>))
 361         .RetiresOnSaturation();
 362     EXPECT_CALL(*delegate, AsyncTexImage2D(_, _, _)).RetiresOnSaturation();
 363
 364     // Command succeeds.
 365     EXPECT_EQ(error::kNoError, ExecuteCmd(teximage_cmd));
 366     EXPECT_EQ(GL_NO_ERROR, GetGLError());
 367   }
 368
 369   // Delegate is cached.
 370   EXPECT_EQ(delegate,
 371             decoder_->GetAsyncPixelTransferManager()->GetPixelTransferDelegate(
 372                 texture_ref));
 373
 374   // Delete delegate on manager teardown.
 375   {
 376     EXPECT_EQ(texture_ref->num_observers(), 1);
 377     EXPECT_CALL(*delegate, Destroy()).RetiresOnSaturation();
 378     decoder_->ResetAsyncPixelTransferManagerForTest();
 379     manager = NULL;
 380
 381     // Texture ref still valid.
 382     EXPECT_EQ(texture_ref, GetTexture(client_texture_id_));
 383     EXPECT_EQ(texture_ref->num_observers(), 0);
 384   }
 385 }
 386
 387 }  // namespace gles2
 388 }  // namespace gpu