Handle multiple textures per buffer in RTCVideoDecoder

content/renderer/media/gpu/rtc_video_decoder_unittest.cc

 // Copyright 2013 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 <stdint.h>
 #include <string.h>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 123 matching lines @@
   }
 
   void RunUntilIdle() {
     DVLOG(2) << "RunUntilIdle";
     vda_task_runner_->PostTask(FROM_HERE,
                                base::Bind(&base::WaitableEvent::Signal,
                                           base::Unretained(&idle_waiter_)));
     idle_waiter_.Wait();
   }
 
+  bool CreateMockTextures(int32_t count,
+                          const gfx::Size& size,
+                          std::vector<uint32_t>* texture_ids,
+                          std::vector<gpu::Mailbox>* texture_mailboxes,
+                          uint32_t texture_target) {
+    texture_ids->resize(count, 0);
+    texture_mailboxes->resize(count, gpu::Mailbox());
+    return true;
+  }
+
+  void ProvidePictureBuffers(uint32_t buffer_count,
+                             media::VideoPixelFormat format,
+                             uint32_t textures_per_buffer,
+                             const gfx::Size& size,
+                             uint32_t texture_target) {
+    vda_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&RTCVideoDecoder::ProvidePictureBuffers,
+                   base::Unretained(rtc_decoder_.get()), buffer_count, format,
+                   textures_per_buffer, size, texture_target));
+    RunUntilIdle();
+  }
+
   void SetUpResetVDA() {
     mock_vda_after_reset_ = new media::MockVideoDecodeAccelerator;
     EXPECT_CALL(*mock_gpu_factories_.get(), DoCreateVideoDecodeAccelerator())
         .WillRepeatedly(Return(mock_vda_after_reset_));
     EXPECT_CALL(*mock_vda_after_reset_, Initialize(_, _))
         .Times(1)
         .WillRepeatedly(Return(true));
     EXPECT_CALL(*mock_vda_after_reset_, Destroy()).Times(1);
   }
 
@@ skipping 115 matching lines @@
       RTCVideoDecoder::ID_HALF + 2, RTCVideoDecoder::ID_HALF));
 
   EXPECT_FALSE(rtc_decoder_->IsFirstBufferAfterReset(RTCVideoDecoder::ID_LAST,
                                                      RTCVideoDecoder::ID_LAST));
   EXPECT_TRUE(
       rtc_decoder_->IsFirstBufferAfterReset(0, RTCVideoDecoder::ID_LAST));
   EXPECT_FALSE(
       rtc_decoder_->IsFirstBufferAfterReset(1, RTCVideoDecoder::ID_LAST));
 }
 
+TEST_F(RTCVideoDecoderTest, MultipleTexturesPerBuffer) {
+  CreateDecoder(webrtc::kVideoCodecVP8);
+  const uint32_t kBufferCount = 5;
+  const uint32_t kTexturesPerBuffer = 3;
+  const gfx::Size kSize(48, 48);
+
+  EXPECT_CALL(*mock_gpu_factories_.get(), CreateTextures(_, _, _, _, _))
+      .WillRepeatedly(Invoke(this, &RTCVideoDecoderTest::CreateMockTextures));
+  EXPECT_CALL(*mock_gpu_factories_.get(), DeleteTexture(_))
+      .Times(kBufferCount * kTexturesPerBuffer);
+
+  std::vector<media::PictureBuffer> pbs;
+  EXPECT_CALL(*mock_vda_, AssignPictureBuffers(_)).WillOnce(SaveArg<0>(&pbs));
+  ProvidePictureBuffers(kBufferCount, media::PIXEL_FORMAT_UNKNOWN,
+                        kTexturesPerBuffer, kSize, 0);
+  EXPECT_EQ(kBufferCount, pbs.size());
+  for (const auto pb : pbs) {
+    EXPECT_EQ(kSize, pb.size());
+    EXPECT_EQ(kTexturesPerBuffer, pb.client_texture_ids().size());
+  }
+}
+
 // Tests/Verifies that |rtc_encoder_| drops incoming frames and its error
 // counter is increased when in an error condition.
 TEST_P(RTCVideoDecoderTest, GetVDAErrorCounterForTesting) {
   const webrtc::VideoCodecType codec_type = GetParam();
   CreateDecoder(codec_type);
   Initialize();
 
   webrtc::EncodedImage input_image;
   input_image._completeFrame = true;
   input_image._encodedWidth = 0;
@@ skipping 45 matching lines @@
   EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
             rtc_decoder_->Decode(input_image, false, nullptr, nullptr, 0));
 }
 
 INSTANTIATE_TEST_CASE_P(CodecProfiles,
                         RTCVideoDecoderTest,
                         Values(webrtc::kVideoCodecVP8,
                                webrtc::kVideoCodecH264));
 
 }  // content