BASELINE: Update Chromium to 85.0.4183.14085-based

Change-Id: Iaa42f4680837c57725b1344f108c0196741f6057
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

13 files changed, 108 insertions, 82 deletions

diff --git a/chromium/media/video/fake_gpu_memory_buffer.cc b/chromium/media/video/fake_gpu_memory_buffer.cc
index 586f1f835a7..6fbdb059a2b 100644
--- a/chromium/media/video/fake_gpu_memory_buffer.cc
+++ b/chromium/media/video/fake_gpu_memory_buffer.cc
@@ -4,7 +4,11 @@
 
 #include "media/video/fake_gpu_memory_buffer.h"
 
+#include "base/atomic_sequence_num.h"
+#include "base/no_destructor.h"
 #include "build/build_config.h"
+#include "media/base/format_utils.h"
+#include "media/base/video_frame.h"
 
 #if defined(OS_LINUX)
 #include <fcntl.h>
@@ -55,26 +59,27 @@ base::ScopedFD GetDummyFD() {
 FakeGpuMemoryBuffer::FakeGpuMemoryBuffer(const gfx::Size& size,
                                          gfx::BufferFormat format)
     : size_(size), format_(format) {
-  // We use only NV12 or R8 in unit tests.
-  CHECK(format == gfx::BufferFormat::YUV_420_BIPLANAR ||
-        format == gfx::BufferFormat::R_8);
+  base::Optional<VideoPixelFormat> video_pixel_format =
+      GfxBufferFormatToVideoPixelFormat(format);
+  CHECK(video_pixel_format);
+  video_pixel_format_ = *video_pixel_format;
 
-  size_t y_plane_size = size_.width() * size_.height();
-  size_t uv_plane_size = size_.width() * size_.height() / 2;
-  data_ = std::vector<uint8_t>(y_plane_size + uv_plane_size);
+  const size_t allocation_size =
+      VideoFrame::AllocationSize(video_pixel_format_, size_);
+  data_ = std::vector<uint8_t>(allocation_size);
 
   handle_.type = gfx::NATIVE_PIXMAP;
-  // Set a dummy id since this is for testing only.
-  handle_.id = gfx::GpuMemoryBufferId(0);
+
+  static base::NoDestructor<base::AtomicSequenceNumber> buffer_id_generator;
+  handle_.id = gfx::GpuMemoryBufferId(buffer_id_generator->GetNext());
 
 #if defined(OS_LINUX)
-  // Set a dummy fd since this is for testing only.
-  handle_.native_pixmap_handle.planes.push_back(
-      gfx::NativePixmapPlane(size_.width(), 0, y_plane_size, GetDummyFD()));
-  if (format == gfx::BufferFormat::YUV_420_BIPLANAR) {
-    handle_.native_pixmap_handle.planes.push_back(gfx::NativePixmapPlane(
-        size_.width(), handle_.native_pixmap_handle.planes[0].size,
-        uv_plane_size, GetDummyFD()));
+  for (size_t i = 0; i < VideoFrame::NumPlanes(video_pixel_format_); i++) {
+    const gfx::Size plane_size_in_bytes =
+        VideoFrame::PlaneSize(video_pixel_format_, i, size_);
+    handle_.native_pixmap_handle.planes.emplace_back(
+        plane_size_in_bytes.width(), 0, plane_size_in_bytes.GetArea(),
+        GetDummyFD());
   }
 #endif  // defined(OS_LINUX)
 }
@@ -86,17 +91,13 @@ bool FakeGpuMemoryBuffer::Map() {
 }
 
 void* FakeGpuMemoryBuffer::memory(size_t plane) {
+  DCHECK_LT(plane, VideoFrame::NumPlanes(video_pixel_format_));
   auto* data_ptr = data_.data();
-  size_t y_plane_size = size_.width() * size_.height();
-  switch (plane) {
-    case 0:
-      return reinterpret_cast<void*>(data_ptr);
-    case 1:
-      return reinterpret_cast<void*>(data_ptr + y_plane_size);
-    default:
-      NOTREACHED() << "Unsupported plane: " << plane;
-      return nullptr;
+  for (size_t i = 1; i <= plane; i++) {
+    data_ptr +=
+        VideoFrame::PlaneSize(video_pixel_format_, i - 1, size_).GetArea();
   }
+  return data_ptr;
 }
 
 void FakeGpuMemoryBuffer::Unmap() {}
@@ -110,15 +111,8 @@ gfx::BufferFormat FakeGpuMemoryBuffer::GetFormat() const {
 }
 
 int FakeGpuMemoryBuffer::stride(size_t plane) const {
-  switch (plane) {
-    case 0:
-      return size_.width();
-    case 1:
-      return size_.width();
-    default:
-      NOTREACHED() << "Unsupported plane: " << plane;
-      return 0;
-  }
+  DCHECK_LT(plane, VideoFrame::NumPlanes(video_pixel_format_));
+  return VideoFrame::PlaneSize(video_pixel_format_, plane, size_).width();
 }
 
 void FakeGpuMemoryBuffer::SetColorSpace(const gfx::ColorSpace& color_space) {}
diff --git a/chromium/media/video/fake_gpu_memory_buffer.h b/chromium/media/video/fake_gpu_memory_buffer.h
index 9ca8cda13d7..9a6499a9609 100644
--- a/chromium/media/video/fake_gpu_memory_buffer.h
+++ b/chromium/media/video/fake_gpu_memory_buffer.h
@@ -8,6 +8,7 @@
 #include <memory>
 
 #include "gpu/ipc/common/gpu_memory_buffer_support.h"
+#include "media/base/video_types.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 
 namespace media {
@@ -39,6 +40,7 @@ class FakeGpuMemoryBuffer : public gfx::GpuMemoryBuffer {
  private:
   gfx::Size size_;
   gfx::BufferFormat format_;
+  VideoPixelFormat video_pixel_format_ = PIXEL_FORMAT_UNKNOWN;
   std::vector<uint8_t> data_;
   gfx::GpuMemoryBufferHandle handle_;
   DISALLOW_IMPLICIT_CONSTRUCTORS(FakeGpuMemoryBuffer);
diff --git a/chromium/media/video/fake_video_encode_accelerator.cc b/chromium/media/video/fake_video_encode_accelerator.cc
index 783f8f0ba7f..8400e49040f 100644
--- a/chromium/media/video/fake_video_encode_accelerator.cc
+++ b/chromium/media/video/fake_video_encode_accelerator.cc
@@ -17,7 +17,7 @@ FakeVideoEncodeAccelerator::FakeVideoEncodeAccelerator(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
     : task_runner_(task_runner),
       will_initialization_succeed_(true),
-      client_(NULL),
+      client_(nullptr),
       next_frame_is_first_frame_(true) {}
 
 FakeVideoEncodeAccelerator::~FakeVideoEncodeAccelerator() {
diff --git a/chromium/media/video/gpu_memory_buffer_video_frame_pool.cc b/chromium/media/video/gpu_memory_buffer_video_frame_pool.cc
index cd549e59c7f..d883b9966ab 100644
--- a/chromium/media/video/gpu_memory_buffer_video_frame_pool.cc
+++ b/chromium/media/video/gpu_memory_buffer_video_frame_pool.cc
@@ -20,6 +20,7 @@
 #include "base/containers/circular_deque.h"
 #include "base/containers/stack_container.h"
 #include "base/location.h"
+#include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
@@ -933,8 +934,7 @@ void GpuMemoryBufferVideoFramePool::PoolImpl::
 #else
   switch (output_format_) {
     case GpuVideoAcceleratorFactories::OutputFormat::I420:
-      allow_overlay =
-          video_frame->metadata()->IsTrue(VideoFrameMetadata::ALLOW_OVERLAY);
+      allow_overlay = video_frame->metadata()->allow_overlay;
       break;
     case GpuVideoAcceleratorFactories::OutputFormat::NV12_SINGLE_GMB:
       allow_overlay = true;
@@ -964,10 +964,8 @@ void GpuMemoryBufferVideoFramePool::PoolImpl::
   }
 #endif  // OS_WIN
   frame->metadata()->MergeMetadataFrom(video_frame->metadata());
-  frame->metadata()->SetBoolean(VideoFrameMetadata::ALLOW_OVERLAY,
-                                allow_overlay);
-  frame->metadata()->SetBoolean(VideoFrameMetadata::READ_LOCK_FENCES_ENABLED,
-                                true);
+  frame->metadata()->allow_overlay = allow_overlay;
+  frame->metadata()->read_lock_fences_enabled = true;
 
   CompleteCopyRequestAndMaybeStartNextCopy(std::move(frame));
 }
diff --git a/chromium/media/video/gpu_memory_buffer_video_frame_pool_unittest.cc b/chromium/media/video/gpu_memory_buffer_video_frame_pool_unittest.cc
index b46a17e5a6e..c624fee627e 100644
--- a/chromium/media/video/gpu_memory_buffer_video_frame_pool_unittest.cc
+++ b/chromium/media/video/gpu_memory_buffer_video_frame_pool_unittest.cc
@@ -283,8 +283,7 @@ TEST_F(GpuMemoryBufferVideoFramePoolTest, CreateOneHardwareNV12Frame) {
   EXPECT_EQ(PIXEL_FORMAT_NV12, frame->format());
   EXPECT_EQ(1u, frame->NumTextures());
   EXPECT_EQ(1u, sii_->shared_image_count());
-  EXPECT_TRUE(frame->metadata()->IsTrue(
-      media::VideoFrameMetadata::READ_LOCK_FENCES_ENABLED));
+  EXPECT_TRUE(frame->metadata()->read_lock_fences_enabled);
 }
 
 TEST_F(GpuMemoryBufferVideoFramePoolTest, CreateOneHardwareNV12Frame2) {
@@ -301,8 +300,7 @@ TEST_F(GpuMemoryBufferVideoFramePoolTest, CreateOneHardwareNV12Frame2) {
   EXPECT_EQ(PIXEL_FORMAT_NV12, frame->format());
   EXPECT_EQ(2u, frame->NumTextures());
   EXPECT_EQ(2u, sii_->shared_image_count());
-  EXPECT_TRUE(frame->metadata()->IsTrue(
-      media::VideoFrameMetadata::READ_LOCK_FENCES_ENABLED));
+  EXPECT_TRUE(frame->metadata()->read_lock_fences_enabled);
 }
 
 TEST_F(GpuMemoryBufferVideoFramePoolTest, CreateOneHardwareXR30Frame) {
@@ -319,8 +317,7 @@ TEST_F(GpuMemoryBufferVideoFramePoolTest, CreateOneHardwareXR30Frame) {
   EXPECT_EQ(PIXEL_FORMAT_XR30, frame->format());
   EXPECT_EQ(1u, frame->NumTextures());
   EXPECT_EQ(1u, sii_->shared_image_count());
-  EXPECT_TRUE(frame->metadata()->IsTrue(
-      media::VideoFrameMetadata::READ_LOCK_FENCES_ENABLED));
+  EXPECT_TRUE(frame->metadata()->read_lock_fences_enabled);
 
   EXPECT_EQ(1u, mock_gpu_factories_->created_memory_buffers().size());
   mock_gpu_factories_->created_memory_buffers()[0]->Map();
@@ -344,8 +341,7 @@ TEST_F(GpuMemoryBufferVideoFramePoolTest, CreateOneHardwareXR30FrameBT709) {
   EXPECT_EQ(PIXEL_FORMAT_XR30, frame->format());
   EXPECT_EQ(1u, frame->NumTextures());
   EXPECT_EQ(1u, sii_->shared_image_count());
-  EXPECT_TRUE(frame->metadata()->IsTrue(
-      media::VideoFrameMetadata::READ_LOCK_FENCES_ENABLED));
+  EXPECT_TRUE(frame->metadata()->read_lock_fences_enabled);
 
   EXPECT_EQ(1u, mock_gpu_factories_->created_memory_buffers().size());
   mock_gpu_factories_->created_memory_buffers()[0]->Map();
@@ -369,8 +365,7 @@ TEST_F(GpuMemoryBufferVideoFramePoolTest, CreateOneHardwareXR30FrameBT601) {
   EXPECT_EQ(PIXEL_FORMAT_XR30, frame->format());
   EXPECT_EQ(1u, frame->NumTextures());
   EXPECT_EQ(1u, sii_->shared_image_count());
-  EXPECT_TRUE(frame->metadata()->IsTrue(
-      media::VideoFrameMetadata::READ_LOCK_FENCES_ENABLED));
+  EXPECT_TRUE(frame->metadata()->read_lock_fences_enabled);
 
   EXPECT_EQ(1u, mock_gpu_factories_->created_memory_buffers().size());
   mock_gpu_factories_->created_memory_buffers()[0]->Map();
@@ -393,8 +388,7 @@ TEST_F(GpuMemoryBufferVideoFramePoolTest, CreateOneHardwareXB30Frame) {
   EXPECT_EQ(PIXEL_FORMAT_XB30, frame->format());
   EXPECT_EQ(1u, frame->NumTextures());
   EXPECT_EQ(1u, sii_->shared_image_count());
-  EXPECT_TRUE(frame->metadata()->IsTrue(
-      media::VideoFrameMetadata::READ_LOCK_FENCES_ENABLED));
+  EXPECT_TRUE(frame->metadata()->read_lock_fences_enabled);
 }
 
 TEST_F(GpuMemoryBufferVideoFramePoolTest, CreateOneHardwareRGBAFrame) {
@@ -411,18 +405,15 @@ TEST_F(GpuMemoryBufferVideoFramePoolTest, CreateOneHardwareRGBAFrame) {
   EXPECT_EQ(PIXEL_FORMAT_ABGR, frame->format());
   EXPECT_EQ(1u, frame->NumTextures());
   EXPECT_EQ(1u, sii_->shared_image_count());
-  EXPECT_TRUE(frame->metadata()->IsTrue(
-      media::VideoFrameMetadata::READ_LOCK_FENCES_ENABLED));
+  EXPECT_TRUE(frame->metadata()->read_lock_fences_enabled);
 }
 
 TEST_F(GpuMemoryBufferVideoFramePoolTest, PreservesMetadata) {
   scoped_refptr<VideoFrame> software_frame = CreateTestYUVVideoFrame(10);
-  software_frame->metadata()->SetBoolean(
-      media::VideoFrameMetadata::END_OF_STREAM, true);
+  software_frame->metadata()->end_of_stream = true;
   base::TimeTicks kTestReferenceTime =
       base::TimeDelta::FromMilliseconds(12345) + base::TimeTicks();
-  software_frame->metadata()->SetTimeTicks(VideoFrameMetadata::REFERENCE_TIME,
-                                           kTestReferenceTime);
+  software_frame->metadata()->reference_time = kTestReferenceTime;
   scoped_refptr<VideoFrame> frame;
   gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
       software_frame, base::BindOnce(MaybeCreateHardwareFrameCallback, &frame));
@@ -430,14 +421,8 @@ TEST_F(GpuMemoryBufferVideoFramePoolTest, PreservesMetadata) {
   RunUntilIdle();
 
   EXPECT_NE(software_frame.get(), frame.get());
-  bool end_of_stream = false;
-  EXPECT_TRUE(frame->metadata()->GetBoolean(
-      media::VideoFrameMetadata::END_OF_STREAM, &end_of_stream));
-  EXPECT_TRUE(end_of_stream);
-  base::TimeTicks render_time;
-  EXPECT_TRUE(frame->metadata()->GetTimeTicks(
-      VideoFrameMetadata::REFERENCE_TIME, &render_time));
-  EXPECT_EQ(kTestReferenceTime, render_time);
+  EXPECT_TRUE(frame->metadata()->end_of_stream);
+  EXPECT_EQ(kTestReferenceTime, *frame->metadata()->reference_time);
 }
 
 // CreateGpuMemoryBuffer can return null (e.g: when the GPU process is down).
@@ -638,8 +623,7 @@ TEST_F(GpuMemoryBufferVideoFramePoolTest, VideoFrameChangesPixelFormat) {
   EXPECT_EQ(PIXEL_FORMAT_ABGR, frame_1->format());
   EXPECT_EQ(1u, frame_1->NumTextures());
   EXPECT_EQ(1u, sii_->shared_image_count());
-  EXPECT_TRUE(frame_1->metadata()->IsTrue(
-      media::VideoFrameMetadata::READ_LOCK_FENCES_ENABLED));
+  EXPECT_TRUE(frame_1->metadata()->read_lock_fences_enabled);
 
   scoped_refptr<VideoFrame> software_frame_2 = CreateTestYUVVideoFrame(10);
   mock_gpu_factories_->SetVideoFrameOutputFormat(
diff --git a/chromium/media/video/gpu_video_accelerator_factories.h b/chromium/media/video/gpu_video_accelerator_factories.h
index cfdbdbb44e1..a12b5fe12ba 100644
--- a/chromium/media/video/gpu_video_accelerator_factories.h
+++ b/chromium/media/video/gpu_video_accelerator_factories.h
@@ -55,7 +55,7 @@ class MediaLog;
 // * The GpuVideoAcceleratorFactories has an associated message loop, which may
 //   be retrieved as |GetMessageLoop()|.
 // * All calls to the Factories after construction must be made on its message
-//   loop.
+//   loop, unless otherwise documented below.
 class MEDIA_EXPORT GpuVideoAcceleratorFactories {
  public:
   enum class OutputFormat {
@@ -90,15 +90,61 @@ class MEDIA_EXPORT GpuVideoAcceleratorFactories {
   // Supported::kFalse if |config| is not supported.
   //
   // May be called on any thread.
+  //
+  // TODO(sandersd): Switch to bool if/when all clients check
+  // IsDecoderSupportKnown().
   virtual Supported IsDecoderConfigSupported(
       VideoDecoderImplementation implementation,
       const VideoDecoderConfig& config) = 0;
 
+  // Returns true if IsDecoderConfigSupported() is ready to answer queries.
+  // Once decoder support is known, it remains known for the lifetime of |this|.
+  //
+  // May be called on any thread.
+  virtual bool IsDecoderSupportKnown() = 0;
+
+  // Registers a callback to be notified when IsDecoderConfigSupported() is
+  // ready to answer queries. The callback will be invoked on the caller's
+  // sequence.
+  //
+  // There is no way to unsubscribe a callback, it is recommended to use a
+  // WeakPtr if you need this feature.
+  //
+  // May be called on any thread.
+  virtual void NotifyDecoderSupportKnown(base::OnceClosure callback) = 0;
+
   virtual std::unique_ptr<media::VideoDecoder> CreateVideoDecoder(
       MediaLog* media_log,
       VideoDecoderImplementation implementation,
       RequestOverlayInfoCB request_overlay_info_cb) = 0;
 
+  // Returns the supported codec profiles of video encode accelerator.
+  // Returns nullopt if GpuVideoAcceleratorFactories don't know the VEA
+  // supported profiles.
+  //
+  // May be called on any thread.
+  //
+  // TODO(sandersd): Remove Optional if/when all clients check
+  // IsEncoderSupportKnown().
+  virtual base::Optional<VideoEncodeAccelerator::SupportedProfiles>
+  GetVideoEncodeAcceleratorSupportedProfiles() = 0;
+
+  // Returns true if GetVideoEncodeAcceleratorSupportedProfiles() is populated.
+  // Once encoder support is known, it remains known for the lifetime of |this|.
+  //
+  // May be called on any thread.
+  virtual bool IsEncoderSupportKnown() = 0;
+
+  // Registers a callback to be notified when
+  // GetVideoEncodeAcceleratorSupportedProfiles() has been populated. The
+  // callback will be invoked on the caller's sequence.
+  //
+  // There is no way to unsubscribe a callback, it is recommended to use a
+  // WeakPtr if you need this feature.
+  //
+  // May be called on any thread.
+  virtual void NotifyEncoderSupportKnown(base::OnceClosure callback) = 0;
+
   // Caller owns returned pointer, but should call Destroy() on it (instead of
   // directly deleting) for proper destruction, as per the
   // VideoEncodeAccelerator interface.
@@ -140,12 +186,6 @@ class MEDIA_EXPORT GpuVideoAcceleratorFactories {
   // Returns the task runner the video accelerator runs on.
   virtual scoped_refptr<base::SingleThreadTaskRunner> GetTaskRunner() = 0;
 
-  // Returns the supported codec profiles of video encode accelerator.
-  // Returns nullopt if GpuVideoAcceleratorFactories don't know the VEA
-  // supported profiles.
-  virtual base::Optional<VideoEncodeAccelerator::SupportedProfiles>
-  GetVideoEncodeAcceleratorSupportedProfiles() = 0;
-
   virtual viz::RasterContextProvider* GetMediaContextProvider() = 0;
 
   // Sets the current pipeline rendering color space.
diff --git a/chromium/media/video/h264_bit_reader.cc b/chromium/media/video/h264_bit_reader.cc
index 0fe227055c2..45c3d75c00c 100644
--- a/chromium/media/video/h264_bit_reader.cc
+++ b/chromium/media/video/h264_bit_reader.cc
@@ -8,7 +8,7 @@
 namespace media {
 
 H264BitReader::H264BitReader()
-    : data_(NULL),
+    : data_(nullptr),
       bytes_left_(0),
       curr_byte_(0),
       num_remaining_bits_in_curr_byte_(0),
diff --git a/chromium/media/video/h264_parser.cc b/chromium/media/video/h264_parser.cc
index f00faf3287d..8dbe250864e 100644
--- a/chromium/media/video/h264_parser.cc
+++ b/chromium/media/video/h264_parser.cc
@@ -8,6 +8,7 @@
 #include <memory>
 
 #include "base/logging.h"
+#include "base/notreached.h"
 #include "base/numerics/safe_math.h"
 #include "base/stl_util.h"
 #include "media/base/subsample_entry.h"
diff --git a/chromium/media/video/mock_gpu_video_accelerator_factories.h b/chromium/media/video/mock_gpu_video_accelerator_factories.h
index 63b5877c01a..6d962f4b939 100644
--- a/chromium/media/video/mock_gpu_video_accelerator_factories.h
+++ b/chromium/media/video/mock_gpu_video_accelerator_factories.h
@@ -34,11 +34,15 @@ class MockGpuVideoAcceleratorFactories : public GpuVideoAcceleratorFactories {
   MOCK_METHOD2(IsDecoderConfigSupported,
                Supported(VideoDecoderImplementation,
                          const VideoDecoderConfig&));
+  MOCK_METHOD0(IsDecoderSupportKnown, bool());
+  MOCK_METHOD1(NotifyDecoderSupportKnown, void(base::OnceClosure));
   MOCK_METHOD3(CreateVideoDecoder,
                std::unique_ptr<media::VideoDecoder>(MediaLog*,
                                                     VideoDecoderImplementation,
                                                     RequestOverlayInfoCB));
 
+  MOCK_METHOD0(IsEncoderSupportKnown, bool());
+  MOCK_METHOD1(NotifyEncoderSupportKnown, void(base::OnceClosure));
   // CreateVideoEncodeAccelerator returns scoped_ptr, which the mocking
   // framework does not want. Trampoline it.
   MOCK_METHOD0(DoCreateVideoEncodeAccelerator, VideoEncodeAccelerator*());
diff --git a/chromium/media/video/picture.cc b/chromium/media/video/picture.cc
index 3e169be0b80..c32b025e7d9 100644
--- a/chromium/media/video/picture.cc
+++ b/chromium/media/video/picture.cc
@@ -4,6 +4,7 @@
 
 #include "media/video/picture.h"
 
+#include "base/check_op.h"
 #include "base/logging.h"
 #include "base/macros.h"
 
diff --git a/chromium/media/video/video_encode_accelerator.cc b/chromium/media/video/video_encode_accelerator.cc
index 81528abd02a..1f1c14d067a 100644
--- a/chromium/media/video/video_encode_accelerator.cc
+++ b/chromium/media/video/video_encode_accelerator.cc
@@ -15,6 +15,8 @@ Vp8Metadata::Vp8Metadata()
 BitstreamBufferMetadata::BitstreamBufferMetadata()
     : payload_size_bytes(0), key_frame(false) {}
 BitstreamBufferMetadata::BitstreamBufferMetadata(
+    const BitstreamBufferMetadata& other) = default;
+BitstreamBufferMetadata::BitstreamBufferMetadata(
     BitstreamBufferMetadata&& other) = default;
 BitstreamBufferMetadata::BitstreamBufferMetadata(size_t payload_size_bytes,
                                                  bool key_frame,
diff --git a/chromium/media/video/video_encode_accelerator.h b/chromium/media/video/video_encode_accelerator.h
index 84a31261293..c0d50d9814e 100644
--- a/chromium/media/video/video_encode_accelerator.h
+++ b/chromium/media/video/video_encode_accelerator.h
@@ -51,6 +51,7 @@ struct MEDIA_EXPORT Vp8Metadata final {
 //  |vp8|, if set, contains metadata specific to VP8. See above.
 struct MEDIA_EXPORT BitstreamBufferMetadata final {
   BitstreamBufferMetadata();
+  BitstreamBufferMetadata(const BitstreamBufferMetadata& other);
   BitstreamBufferMetadata(BitstreamBufferMetadata&& other);
   BitstreamBufferMetadata(size_t payload_size_bytes,
                           bool key_frame,
diff --git a/chromium/media/video/vpx_video_encoder.cc b/chromium/media/video/vpx_video_encoder.cc
index 808d585b919..696afed6ee5 100644
--- a/chromium/media/video/vpx_video_encoder.cc
+++ b/chromium/media/video/vpx_video_encoder.cc
@@ -221,12 +221,11 @@ void VpxVideoEncoder::ChangeOptions(const Options& options, StatusCB done_cb) {
 }
 
 uint64_t VpxVideoEncoder::GetFrameDuration(const VideoFrame& frame) {
-  base::TimeDelta result;
-  if (!frame.metadata()->GetTimeDelta(media::VideoFrameMetadata::FRAME_DURATION,
-                                      &result)) {
-    result = base::TimeDelta::FromSecondsD(1.0 / options_.framerate);
-  }
-  return result.InMicroseconds();
+  base::TimeDelta default_duration =
+      base::TimeDelta::FromSecondsD(1.0 / options_.framerate);
+  return frame.metadata()
+      ->frame_duration.value_or(default_duration)
+      .InMicroseconds();
 }
 
 VpxVideoEncoder::~VpxVideoEncoder() {