media/renderers/resource_sync_token_client_unittest.cc

   1 // Copyright 2023 The Chromium Authors
   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 "media/renderers/resource_sync_token_client.h"
   6
   7 #include <vector>
   8
   9 #include "components/viz/test/test_gles2_interface.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 namespace {
  13
  14 gpu::SyncToken CreateSyncToken(int value) {
  15   return gpu::SyncToken(gpu::CommandBufferNamespace::GPU_IO,
  16                         gpu::CommandBufferId::FromUnsafeValue(value), 0);
  17 }
  18
  19 class SyncTokenTestInterface : public viz::TestGLES2Interface {
  20  public:
  21   void GenSyncTokenCHROMIUM(GLbyte* sync_token) override {
  22     viz::TestGLES2Interface::GenSyncTokenCHROMIUM(sync_token);
  23     gpu::SyncToken sync_token_data;
  24     memcpy(sync_token_data.GetData(), sync_token, sizeof(sync_token_data));
  25     generated_tokens_.push_back(sync_token_data);
  26   }
  27
  28   void WaitSyncTokenCHROMIUM(const GLbyte* sync_token) override {
  29     gpu::SyncToken sync_token_data;
  30     memcpy(sync_token_data.GetData(), sync_token, sizeof(sync_token_data));
  31     viz::TestGLES2Interface::WaitSyncTokenCHROMIUM(sync_token);
  32     waited_tokens_.push_back(sync_token_data);
  33   }
  34
  35   const std::vector<gpu::SyncToken>& generated_tokens() const {
  36     return generated_tokens_;
  37   }
  38   const std::vector<gpu::SyncToken>& waited_tokens() const {
  39     return waited_tokens_;
  40   }
  41
  42  private:
  43   std::vector<gpu::SyncToken> generated_tokens_;
  44   std::vector<gpu::SyncToken> waited_tokens_;
  45 };
  46
  47 }  // namespace
  48
  49 namespace media {
  50
  51 // Test that no additional work is triggered when receiving a duplicated
  52 // SyncToken.
  53 TEST(ResourceSyncTokenClientTest, DuplicateToken) {
  54   SyncTokenTestInterface gl;
  55
  56   auto token = CreateSyncToken(0x1234);
  57   ResourceSyncTokenClient client(&gl, token, token);
  58   client.WaitSyncToken(token);
  59   EXPECT_TRUE(gl.generated_tokens().empty());
  60   EXPECT_TRUE(gl.waited_tokens().empty());
  61
  62   gpu::SyncToken generated_token;
  63   client.GenerateSyncToken(&generated_token);
  64   EXPECT_EQ(generated_token, token);
  65   EXPECT_TRUE(gl.generated_tokens().empty());
  66   EXPECT_TRUE(gl.waited_tokens().empty());
  67 }
  68
  69 // Test that no additional work is triggered when the token waited on matches
  70 // the original token.
  71 TEST(ResourceSyncTokenClientTest, MatchesOriginalToken) {
  72   SyncTokenTestInterface gl;
  73
  74   auto original_token = CreateSyncToken(0xDEED);
  75   auto token = CreateSyncToken(0x1234);
  76   ResourceSyncTokenClient client(&gl, original_token, token);
  77   client.WaitSyncToken(original_token);
  78   EXPECT_TRUE(gl.generated_tokens().empty());
  79   EXPECT_TRUE(gl.waited_tokens().empty());
  80
  81   gpu::SyncToken generated_token;
  82   client.GenerateSyncToken(&generated_token);
  83   EXPECT_EQ(generated_token, token);
  84   EXPECT_TRUE(gl.generated_tokens().empty());
  85   EXPECT_TRUE(gl.waited_tokens().empty());
  86 }
  87
  88 // Test that the appropriate waits and token generation happen when the
  89 // token waited upon is different than the original token.
  90 TEST(ResourceSyncTokenClientTest, NewFrameToken) {
  91   SyncTokenTestInterface gl;
  92
  93   auto original_token = CreateSyncToken(0xDEED);
  94   auto token = CreateSyncToken(0x1234);
  95   ResourceSyncTokenClient client(&gl, original_token, token);
  96
  97   auto new_token = CreateSyncToken(0xBEED);
  98   client.WaitSyncToken(new_token);
  99   ASSERT_EQ(gl.waited_tokens().size(), 2u);
 100   EXPECT_EQ(gl.waited_tokens()[0], new_token);
 101   EXPECT_EQ(gl.waited_tokens()[1], token);
 102
 103   gpu::SyncToken generated_token;
 104   client.GenerateSyncToken(&generated_token);
 105   EXPECT_NE(generated_token, original_token);
 106   EXPECT_NE(generated_token, token);
 107   EXPECT_NE(generated_token, new_token);
 108   ASSERT_EQ(gl.generated_tokens().size(), 1u);
 109   EXPECT_EQ(gl.generated_tokens()[0], generated_token);
 110 }
 111
 112 }  // namespace media