Revert of Add accelerated VP9 decode infrastructure and an implementation for VA-API.

content/common/gpu/media/vaapi_video_decode_accelerator.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.
 
 #include "content/common/gpu/media/vaapi_video_decode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/media/accelerated_video_decoder.h"
 #include "content/common/gpu/media/h264_decoder.h"
 #include "content/common/gpu/media/vaapi_picture.h"
 #include "content/common/gpu/media/vp8_decoder.h"
-#include "content/common/gpu/media/vp9_decoder.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/video/picture.h"
 #include "third_party/libva/va/va_dec_vp8.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_image.h"
 
 namespace content {
 
 namespace {
 // UMA errors that the VaapiVideoDecodeAccelerator class reports.
@@ skipping 162 matching lines @@
  private:
   scoped_refptr<VaapiDecodeSurface> VP8PictureToVaapiDecodeSurface(
       const scoped_refptr<VP8Picture>& pic);
 
   VaapiWrapper* vaapi_wrapper_;
   VaapiVideoDecodeAccelerator* vaapi_dec_;
 
   DISALLOW_COPY_AND_ASSIGN(VaapiVP8Accelerator);
 };
 
-class VaapiVP9Picture : public VP9Picture {
- public:
-  VaapiVP9Picture(
-      const scoped_refptr<VaapiVideoDecodeAccelerator::VaapiDecodeSurface>&
-          dec_surface);
-
-  VaapiVP9Picture* AsVaapiVP9Picture() override { return this; }
-  scoped_refptr<VaapiVideoDecodeAccelerator::VaapiDecodeSurface> dec_surface() {
-    return dec_surface_;
-  }
-
- private:
-  ~VaapiVP9Picture() override;
-
-  scoped_refptr<VaapiVideoDecodeAccelerator::VaapiDecodeSurface> dec_surface_;
-
-  DISALLOW_COPY_AND_ASSIGN(VaapiVP9Picture);
-};
-
-VaapiVP9Picture::VaapiVP9Picture(
-    const scoped_refptr<VaapiVideoDecodeAccelerator::VaapiDecodeSurface>&
-        dec_surface)
-    : dec_surface_(dec_surface) {}
-
-VaapiVP9Picture::~VaapiVP9Picture() {}
-
-class VaapiVideoDecodeAccelerator::VaapiVP9Accelerator
-    : public VP9Decoder::VP9Accelerator {
- public:
-  VaapiVP9Accelerator(VaapiVideoDecodeAccelerator* vaapi_dec,
-                      VaapiWrapper* vaapi_wrapper);
-  ~VaapiVP9Accelerator() override;
-
-  // VP9Decoder::VP9Accelerator implementation.
-  scoped_refptr<VP9Picture> CreateVP9Picture() override;
-
-  bool SubmitDecode(
-      const scoped_refptr<VP9Picture>& pic,
-      const media::Vp9Segmentation& seg,
-      const media::Vp9LoopFilter& lf,
-      const std::vector<scoped_refptr<VP9Picture>>& ref_pictures) override;
-
-  bool OutputPicture(const scoped_refptr<VP9Picture>& pic) override;
-
- private:
-  scoped_refptr<VaapiDecodeSurface> VP9PictureToVaapiDecodeSurface(
-      const scoped_refptr<VP9Picture>& pic);
-
-  VaapiWrapper* vaapi_wrapper_;
-  VaapiVideoDecodeAccelerator* vaapi_dec_;
-
-  DISALLOW_COPY_AND_ASSIGN(VaapiVP9Accelerator);
-};
-
 VaapiVideoDecodeAccelerator::InputBuffer::InputBuffer() : id(0), size(0) {
 }
 
 VaapiVideoDecodeAccelerator::InputBuffer::~InputBuffer() {
 }
 
 void VaapiVideoDecodeAccelerator::NotifyError(Error error) {
   if (message_loop_ != base::MessageLoop::current()) {
     DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
     message_loop_->PostTask(FROM_HERE, base::Bind(
@@ skipping 83 matching lines @@
   }
 
   if (profile >= media::H264PROFILE_MIN && profile <= media::H264PROFILE_MAX) {
     h264_accelerator_.reset(
         new VaapiH264Accelerator(this, vaapi_wrapper_.get()));
     decoder_.reset(new H264Decoder(h264_accelerator_.get()));
   } else if (profile >= media::VP8PROFILE_MIN &&
              profile <= media::VP8PROFILE_MAX) {
     vp8_accelerator_.reset(new VaapiVP8Accelerator(this, vaapi_wrapper_.get()));
     decoder_.reset(new VP8Decoder(vp8_accelerator_.get()));
-  } else if (profile >= media::VP9PROFILE_MIN &&
-             profile <= media::VP9PROFILE_MAX) {
-    vp9_accelerator_.reset(new VaapiVP9Accelerator(this, vaapi_wrapper_.get()));
-    decoder_.reset(new VP9Decoder(vp9_accelerator_.get()));
   } else {
     DLOG(ERROR) << "Unsupported profile " << profile;
     return false;
   }
 
   CHECK(decoder_thread_.Start());
   decoder_thread_task_runner_ = decoder_thread_.task_runner();
 
   state_ = kIdle;
   return true;
@@ skipping 666 matching lines @@
     const media::H264SPS* sps,
     const media::H264PPS* pps,
     const H264DPB& dpb,
     const H264Picture::Vector& ref_pic_listp0,
     const H264Picture::Vector& ref_pic_listb0,
     const H264Picture::Vector& ref_pic_listb1,
     const scoped_refptr<H264Picture>& pic) {
   VAPictureParameterBufferH264 pic_param;
   memset(&pic_param, 0, sizeof(pic_param));
 
-#define FROM_SPS_TO_PP(a) pic_param.a = sps->a
-#define FROM_SPS_TO_PP2(a, b) pic_param.b = sps->a
+#define FROM_SPS_TO_PP(a) pic_param.a = sps->a;
+#define FROM_SPS_TO_PP2(a, b) pic_param.b = sps->a;
   FROM_SPS_TO_PP2(pic_width_in_mbs_minus1, picture_width_in_mbs_minus1);
   // This assumes non-interlaced video
   FROM_SPS_TO_PP2(pic_height_in_map_units_minus1, picture_height_in_mbs_minus1);
   FROM_SPS_TO_PP(bit_depth_luma_minus8);
   FROM_SPS_TO_PP(bit_depth_chroma_minus8);
 #undef FROM_SPS_TO_PP
 #undef FROM_SPS_TO_PP2
 
-#define FROM_SPS_TO_PP_SF(a) pic_param.seq_fields.bits.a = sps->a
-#define FROM_SPS_TO_PP_SF2(a, b) pic_param.seq_fields.bits.b = sps->a
+#define FROM_SPS_TO_PP_SF(a) pic_param.seq_fields.bits.a = sps->a;
+#define FROM_SPS_TO_PP_SF2(a, b) pic_param.seq_fields.bits.b = sps->a;
   FROM_SPS_TO_PP_SF(chroma_format_idc);
   FROM_SPS_TO_PP_SF2(separate_colour_plane_flag,
                      residual_colour_transform_flag);
   FROM_SPS_TO_PP_SF(gaps_in_frame_num_value_allowed_flag);
   FROM_SPS_TO_PP_SF(frame_mbs_only_flag);
   FROM_SPS_TO_PP_SF(mb_adaptive_frame_field_flag);
   FROM_SPS_TO_PP_SF(direct_8x8_inference_flag);
   pic_param.seq_fields.bits.MinLumaBiPredSize8x8 = (sps->level_idc >= 31);
   FROM_SPS_TO_PP_SF(log2_max_frame_num_minus4);
   FROM_SPS_TO_PP_SF(pic_order_cnt_type);
   FROM_SPS_TO_PP_SF(log2_max_pic_order_cnt_lsb_minus4);
   FROM_SPS_TO_PP_SF(delta_pic_order_always_zero_flag);
 #undef FROM_SPS_TO_PP_SF
 #undef FROM_SPS_TO_PP_SF2
 
-#define FROM_PPS_TO_PP(a) pic_param.a = pps->a
+#define FROM_PPS_TO_PP(a) pic_param.a = pps->a;
   FROM_PPS_TO_PP(num_slice_groups_minus1);
   pic_param.slice_group_map_type = 0;
   pic_param.slice_group_change_rate_minus1 = 0;
   FROM_PPS_TO_PP(pic_init_qp_minus26);
   FROM_PPS_TO_PP(pic_init_qs_minus26);
   FROM_PPS_TO_PP(chroma_qp_index_offset);
   FROM_PPS_TO_PP(second_chroma_qp_index_offset);
 #undef FROM_PPS_TO_PP
 
-#define FROM_PPS_TO_PP_PF(a) pic_param.pic_fields.bits.a = pps->a
-#define FROM_PPS_TO_PP_PF2(a, b) pic_param.pic_fields.bits.b = pps->a
+#define FROM_PPS_TO_PP_PF(a) pic_param.pic_fields.bits.a = pps->a;
+#define FROM_PPS_TO_PP_PF2(a, b) pic_param.pic_fields.bits.b = pps->a;
   FROM_PPS_TO_PP_PF(entropy_coding_mode_flag);
   FROM_PPS_TO_PP_PF(weighted_pred_flag);
   FROM_PPS_TO_PP_PF(weighted_bipred_idc);
   FROM_PPS_TO_PP_PF(transform_8x8_mode_flag);
 
   pic_param.pic_fields.bits.field_pic_flag = 0;
   FROM_PPS_TO_PP_PF(constrained_intra_pred_flag);
   FROM_PPS_TO_PP_PF2(bottom_field_pic_order_in_frame_present_flag,
                      pic_order_present_flag);
   FROM_PPS_TO_PP_PF(deblocking_filter_control_present_flag);
@@ skipping 61 matching lines @@
     const uint8_t* data,
     size_t size) {
   VASliceParameterBufferH264 slice_param;
   memset(&slice_param, 0, sizeof(slice_param));
 
   slice_param.slice_data_size = slice_hdr->nalu_size;
   slice_param.slice_data_offset = 0;
   slice_param.slice_data_flag = VA_SLICE_DATA_FLAG_ALL;
   slice_param.slice_data_bit_offset = slice_hdr->header_bit_size;
 
-#define SHDRToSP(a) slice_param.a = slice_hdr->a
+#define SHDRToSP(a) slice_param.a = slice_hdr->a;
   SHDRToSP(first_mb_in_slice);
   slice_param.slice_type = slice_hdr->slice_type % 5;
   SHDRToSP(direct_spatial_mv_pred_flag);
 
   // TODO posciak: make sure parser sets those even when override flags
   // in slice header is off.
   SHDRToSP(num_ref_idx_l0_active_minus1);
   SHDRToSP(num_ref_idx_l1_active_minus1);
   SHDRToSP(cabac_init_idc);
   SHDRToSP(slice_qp_delta);
@@ skipping 262 matching lines @@
         VP8PictureToVaapiDecodeSurface(alt_frame);
     pic_param.alt_ref_frame = alt_frame_surface->va_surface()->id();
   } else {
     pic_param.alt_ref_frame = VA_INVALID_SURFACE;
   }
 
   pic_param.out_of_loop_frame = VA_INVALID_SURFACE;
 
   const media::Vp8LoopFilterHeader& lf_hdr = frame_hdr->loopfilter_hdr;
 
-#define FHDR_TO_PP_PF(a, b) pic_param.pic_fields.bits.a = (b)
+#define FHDR_TO_PP_PF(a, b) pic_param.pic_fields.bits.a = (b);
   FHDR_TO_PP_PF(key_frame, frame_hdr->IsKeyframe() ? 0 : 1);
   FHDR_TO_PP_PF(version, frame_hdr->version);
   FHDR_TO_PP_PF(segmentation_enabled, sgmnt_hdr.segmentation_enabled);
   FHDR_TO_PP_PF(update_mb_segmentation_map,
                 sgmnt_hdr.update_mb_segmentation_map);
   FHDR_TO_PP_PF(update_segment_feature_data,
                 sgmnt_hdr.update_segment_feature_data);
   FHDR_TO_PP_PF(filter_type, lf_hdr.type);
   FHDR_TO_PP_PF(sharpness_level, lf_hdr.sharpness_level);
   FHDR_TO_PP_PF(loop_filter_adj_enable, lf_hdr.loop_filter_adj_enable);
@@ skipping 29 matching lines @@
                 arraysize(lf_hdr.mb_mode_delta) ==
                     arraysize(pic_param.loop_filter_deltas_mode) &&
                 arraysize(lf_hdr.ref_frame_delta) ==
                     arraysize(lf_hdr.mb_mode_delta),
                 "loop filter deltas arrays size mismatch");
   for (size_t i = 0; i < arraysize(lf_hdr.ref_frame_delta); ++i) {
     pic_param.loop_filter_deltas_ref_frame[i] = lf_hdr.ref_frame_delta[i];
     pic_param.loop_filter_deltas_mode[i] = lf_hdr.mb_mode_delta[i];
   }
 
-#define FHDR_TO_PP(a) pic_param.a = frame_hdr->a
+#define FHDR_TO_PP(a) pic_param.a = frame_hdr->a;
   FHDR_TO_PP(prob_skip_false);
   FHDR_TO_PP(prob_intra);
   FHDR_TO_PP(prob_last);
   FHDR_TO_PP(prob_gf);
 #undef FHDR_TO_PP
 
   ARRAY_MEMCPY_CHECKED(pic_param.y_mode_probs, entr_hdr.y_mode_probs);
   ARRAY_MEMCPY_CHECKED(pic_param.uv_mode_probs, entr_hdr.uv_mode_probs);
   ARRAY_MEMCPY_CHECKED(pic_param.mv_probs, entr_hdr.mv_probs);
 
   pic_param.bool_coder_ctx.range = frame_hdr->bool_dec_range;
   pic_param.bool_coder_ctx.value = frame_hdr->bool_dec_value;
   pic_param.bool_coder_ctx.count = frame_hdr->bool_dec_count;
 
   if (!vaapi_wrapper_->SubmitBuffer(VAPictureParameterBufferType,
-                                    sizeof(pic_param), &pic_param))
+                                    sizeof(VAPictureParameterBufferVP8),
+                                    &pic_param))
     return false;
 
   VASliceParameterBufferVP8 slice_param;
-  memset(&slice_param, 0, sizeof(slice_param));
+  memset(&slice_param, 0, sizeof(VASliceParameterBufferVP8));
   slice_param.slice_data_size = frame_hdr->frame_size;
   slice_param.slice_data_offset = frame_hdr->first_part_offset;
   slice_param.slice_data_flag = VA_SLICE_DATA_FLAG_ALL;
   slice_param.macroblock_offset = frame_hdr->macroblock_bit_offset;
   // Number of DCT partitions plus control partition.
   slice_param.num_of_partitions = frame_hdr->num_of_dct_partitions + 1;
 
   // Per VAAPI, this size only includes the size of the macroblock data in
   // the first partition (in bytes), so we have to subtract the header size.
   slice_param.partition_size[0] =
@@ skipping 29 matching lines @@
 }
 
 scoped_refptr<VaapiVideoDecodeAccelerator::VaapiDecodeSurface>
 VaapiVideoDecodeAccelerator::VaapiVP8Accelerator::
     VP8PictureToVaapiDecodeSurface(const scoped_refptr<VP8Picture>& pic) {
   VaapiVP8Picture* vaapi_pic = pic->AsVaapiVP8Picture();
   CHECK(vaapi_pic);
   return vaapi_pic->dec_surface();
 }
 
-VaapiVideoDecodeAccelerator::VaapiVP9Accelerator::VaapiVP9Accelerator(
-    VaapiVideoDecodeAccelerator* vaapi_dec,
-    VaapiWrapper* vaapi_wrapper)
-    : vaapi_wrapper_(vaapi_wrapper), vaapi_dec_(vaapi_dec) {
-  DCHECK(vaapi_wrapper_);
-  DCHECK(vaapi_dec_);
-}
-
-VaapiVideoDecodeAccelerator::VaapiVP9Accelerator::~VaapiVP9Accelerator() {}
-
-scoped_refptr<VP9Picture>
-VaapiVideoDecodeAccelerator::VaapiVP9Accelerator::CreateVP9Picture() {
-  scoped_refptr<VaapiDecodeSurface> va_surface = vaapi_dec_->CreateSurface();
-  if (!va_surface)
-    return nullptr;
-
-  return new VaapiVP9Picture(va_surface);
-}
-
-bool VaapiVideoDecodeAccelerator::VaapiVP9Accelerator::SubmitDecode(
-    const scoped_refptr<VP9Picture>& pic,
-    const media::Vp9Segmentation& seg,
-    const media::Vp9LoopFilter& lf,
-    const std::vector<scoped_refptr<VP9Picture>>& ref_pictures) {
-  VADecPictureParameterBufferVP9 pic_param;
-  memset(&pic_param, 0, sizeof(pic_param));
-
-  const media::Vp9FrameHeader* frame_hdr = pic->frame_hdr.get();
-  DCHECK(frame_hdr);
-
-  if (frame_hdr->profile != 0) {
-    DVLOG(1) << "Unsupported profile" << frame_hdr->profile;
-    return false;
-  }
-
-  pic_param.frame_width = base::checked_cast<uint16_t>(frame_hdr->width);
-  pic_param.frame_height = base::checked_cast<uint16_t>(frame_hdr->height);
-
-  CHECK_EQ(ref_pictures.size(), arraysize(pic_param.reference_frames));
-  for (size_t i = 0; i < arraysize(pic_param.reference_frames); ++i) {
-    VASurfaceID va_surface_id;
-    if (ref_pictures[i]) {
-      scoped_refptr<VaapiDecodeSurface> surface =
-          VP9PictureToVaapiDecodeSurface(ref_pictures[i]);
-      va_surface_id = surface->va_surface()->id();
-    } else {
-      va_surface_id = VA_INVALID_SURFACE;
-    }
-
-    pic_param.reference_frames[i] = va_surface_id;
-  }
-
-#define FHDR_TO_PP_PF1(a) pic_param.pic_fields.bits.a = frame_hdr->a
-#define FHDR_TO_PP_PF2(a, b) pic_param.pic_fields.bits.a = b
-  FHDR_TO_PP_PF2(subsampling_x, frame_hdr->subsampling_x == 1);
-  FHDR_TO_PP_PF2(subsampling_y, frame_hdr->subsampling_y == 1);
-  FHDR_TO_PP_PF2(frame_type, frame_hdr->IsKeyframe() ? 0 : 1);
-  FHDR_TO_PP_PF1(show_frame);
-  FHDR_TO_PP_PF1(error_resilient_mode);
-  FHDR_TO_PP_PF1(intra_only);
-  FHDR_TO_PP_PF1(allow_high_precision_mv);
-  FHDR_TO_PP_PF2(mcomp_filter_type, frame_hdr->interp_filter);
-  FHDR_TO_PP_PF1(frame_parallel_decoding_mode);
-  FHDR_TO_PP_PF2(reset_frame_context, frame_hdr->reset_context);
-  FHDR_TO_PP_PF1(refresh_frame_context);
-  FHDR_TO_PP_PF1(frame_context_idx);
-  FHDR_TO_PP_PF2(segmentation_enabled, seg.enabled);
-  FHDR_TO_PP_PF2(segmentation_temporal_update, seg.temporal_update);
-  FHDR_TO_PP_PF2(segmentation_update_map, seg.update_map);
-  FHDR_TO_PP_PF2(last_ref_frame, frame_hdr->frame_refs[0]);
-  FHDR_TO_PP_PF2(last_ref_frame_sign_bias, frame_hdr->ref_sign_biases[0]);
-  FHDR_TO_PP_PF2(golden_ref_frame, frame_hdr->frame_refs[1]);
-  FHDR_TO_PP_PF2(golden_ref_frame_sign_bias, frame_hdr->ref_sign_biases[1]);
-  FHDR_TO_PP_PF2(alt_ref_frame, frame_hdr->frame_refs[2]);
-  FHDR_TO_PP_PF2(alt_ref_frame_sign_bias, frame_hdr->ref_sign_biases[2]);
-  FHDR_TO_PP_PF2(lossless_flag, frame_hdr->quant_params.IsLossless());
-#undef FHDR_TO_PP_PF2
-#undef FHDR_TO_PP_PF1
-
-  pic_param.filter_level = lf.filter_level;
-  pic_param.sharpness_level = lf.sharpness_level;
-  pic_param.log2_tile_rows = frame_hdr->log2_tile_rows;
-  pic_param.log2_tile_columns = frame_hdr->log2_tile_cols;
-  pic_param.frame_header_length_in_bytes = frame_hdr->uncompressed_header_size;
-  pic_param.first_partition_size = frame_hdr->first_partition_size;
-
-  ARRAY_MEMCPY_CHECKED(pic_param.mb_segment_tree_probs, seg.tree_probs);
-  ARRAY_MEMCPY_CHECKED(pic_param.segment_pred_probs, seg.pred_probs);
-
-  pic_param.profile = frame_hdr->profile;
-
-  if (!vaapi_wrapper_->SubmitBuffer(VAPictureParameterBufferType,
-                                    sizeof(pic_param), &pic_param))
-    return false;
-
-  VASliceParameterBufferVP9 slice_param;
-  memset(&slice_param, 0, sizeof(slice_param));
-  slice_param.slice_data_size = frame_hdr->frame_size;
-  slice_param.slice_data_offset = 0;
-  slice_param.slice_data_flag = VA_SLICE_DATA_FLAG_ALL;
-
-  static_assert(arraysize(media::Vp9Segmentation::feature_enabled) ==
-                    arraysize(slice_param.seg_param),
-                "seg_param array of incorrect size");
-  for (size_t i = 0; i < arraysize(slice_param.seg_param); ++i) {
-    VASegmentParameterVP9& seg_param = slice_param.seg_param[i];
-#define SEG_TO_SP_SF(a, b) seg_param.segment_flags.fields.a = b
-    SEG_TO_SP_SF(
-        segment_reference_enabled,
-        seg.FeatureEnabled(i, media::Vp9Segmentation::SEG_LVL_REF_FRAME));
-    SEG_TO_SP_SF(segment_reference,
-                 seg.FeatureData(i, media::Vp9Segmentation::SEG_LVL_REF_FRAME));
-    SEG_TO_SP_SF(segment_reference_skipped,
-                 seg.FeatureEnabled(i, media::Vp9Segmentation::SEG_LVL_SKIP));
-#undef SEG_TO_SP_SF
-
-    ARRAY_MEMCPY_CHECKED(seg_param.filter_level, lf.lvl[i]);
-
-    seg_param.luma_dc_quant_scale = seg.y_dequant[i][0];
-    seg_param.luma_ac_quant_scale = seg.y_dequant[i][1];
-    seg_param.chroma_dc_quant_scale = seg.uv_dequant[i][0];
-    seg_param.chroma_ac_quant_scale = seg.uv_dequant[i][1];
-  }
-
-  if (!vaapi_wrapper_->SubmitBuffer(VASliceParameterBufferType,
-                                    sizeof(slice_param), &slice_param))
-    return false;
-
-  void* non_const_ptr = const_cast<uint8*>(frame_hdr->data);
-  if (!vaapi_wrapper_->SubmitBuffer(VASliceDataBufferType,
-                                    frame_hdr->frame_size, non_const_ptr))
-    return false;
-
-  scoped_refptr<VaapiDecodeSurface> dec_surface =
-      VP9PictureToVaapiDecodeSurface(pic);
-
-  return vaapi_dec_->DecodeSurface(dec_surface);
-}
-
-bool VaapiVideoDecodeAccelerator::VaapiVP9Accelerator::OutputPicture(
-    const scoped_refptr<VP9Picture>& pic) {
-  scoped_refptr<VaapiDecodeSurface> dec_surface =
-      VP9PictureToVaapiDecodeSurface(pic);
-
-  vaapi_dec_->SurfaceReady(dec_surface);
-  return true;
-}
-
-scoped_refptr<VaapiVideoDecodeAccelerator::VaapiDecodeSurface>
-VaapiVideoDecodeAccelerator::VaapiVP9Accelerator::
-    VP9PictureToVaapiDecodeSurface(const scoped_refptr<VP9Picture>& pic) {
-  VaapiVP9Picture* vaapi_pic = pic->AsVaapiVP9Picture();
-  CHECK(vaapi_pic);
-  return vaapi_pic->dec_surface();
-}
-
 // static
 media::VideoDecodeAccelerator::SupportedProfiles
 VaapiVideoDecodeAccelerator::GetSupportedProfiles() {
   return VaapiWrapper::GetSupportedDecodeProfiles();
 }
 
 }  // namespace content