Replace const scoped_refptr<H264Picture>& everywhere

Bug: 890054
Change-Id: I91cb2f1365ba5eb0ead2440fbc08e785eb5a58c4
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1601688
Commit-Queue: Ted Meyer <tmathmeyer@chromium.org>
Reviewed-by: John Rummell <jrummell@chromium.org>
Cr-Commit-Position: refs/heads/master@{#659739}

media/gpu/h264_decoder.cc

@@ -446,20 +446,17 @@ void H264Decoder::ConstructReferencePicListsB(
 }
 
 // See 8.2.4
-int H264Decoder::PicNumF(const scoped_refptr<H264Picture>& pic) {
-  if (!pic)
-    return -1;
-
-  if (!pic->long_term)
-    return pic->pic_num;
+int H264Decoder::PicNumF(const H264Picture& pic) {
+  if (!pic.long_term)
+    return pic.pic_num;
   else
     return max_pic_num_;
 }
 
 // See 8.2.4
-int H264Decoder::LongTermPicNumF(const scoped_refptr<H264Picture>& pic) {
-  if (pic->ref && pic->long_term)
-    return pic->long_term_pic_num;
+int H264Decoder::LongTermPicNumF(const H264Picture& pic) {
+  if (pic.ref && pic.long_term)
+    return pic.long_term_pic_num;
   else
     return 2 * (max_long_term_frame_idx_ + 1);
 }
@@ -469,7 +466,7 @@ int H264Decoder::LongTermPicNumF(const scoped_refptr<H264Picture>& pic) {
 static void ShiftRightAndInsert(H264Picture::Vector* v,
                                 int from,
                                 int to,
-                                const scoped_refptr<H264Picture>& pic) {
+                                scoped_refptr<H264Picture> pic) {
   // Security checks, do not disable in Debug mode.
   CHECK(from <= to);
   CHECK(to <= std::numeric_limits<int>::max() - 2);
@@ -484,7 +481,7 @@ static void ShiftRightAndInsert(H264Picture::Vector* v,
   for (int i = to + 1; i > from; --i)
     (*v)[i] = (*v)[i - 1];
 
-  (*v)[from] = pic;
+  (*v)[from] = std::move(pic);
 }
 
 bool H264Decoder::ModifyReferencePicList(const H264SliceHeader* slice_hdr,
@@ -573,7 +570,9 @@ bool H264Decoder::ModifyReferencePicList(const H264SliceHeader* slice_hdr,
 
         for (int src = ref_idx_lx, dst = ref_idx_lx;
              src <= num_ref_idx_lX_active_minus1 + 1; ++src) {
-          if (PicNumF((*ref_pic_listx)[src]) != pic_num_lx)
+          auto* src_pic = (*ref_pic_listx)[src].get();
+          int src_pic_num_lx = src_pic ? PicNumF(*src_pic) : -1;
+          if (src_pic_num_lx != pic_num_lx)
             (*ref_pic_listx)[dst++] = (*ref_pic_listx)[src];
         }
         break;
@@ -594,7 +593,7 @@ bool H264Decoder::ModifyReferencePicList(const H264SliceHeader* slice_hdr,
 
         for (int src = ref_idx_lx, dst = ref_idx_lx;
              src <= num_ref_idx_lX_active_minus1 + 1; ++src) {
-          if (LongTermPicNumF((*ref_pic_listx)[src]) !=
+          if (LongTermPicNumF(*(*ref_pic_listx)[src]) !=
               static_cast<int>(list_mod->long_term_pic_num))
             (*ref_pic_listx)[dst++] = (*ref_pic_listx)[src];
         }

media/gpu/h264_decoder.h

@@ -88,7 +88,7 @@ class MEDIA_GPU_EXPORT H264Decoder : public AcceleratedVideoDecoder {
         const H264Picture::Vector& ref_pic_listp0,
         const H264Picture::Vector& ref_pic_listb0,
         const H264Picture::Vector& ref_pic_listb1,
-        const scoped_refptr<H264Picture>& pic) = 0;
+        scoped_refptr<H264Picture> pic) = 0;
 
     // Submit one slice for the current frame, passing the current |pps| and
     // |pic| (same as in SubmitFrameMetadata()), the parsed header for the
@@ -106,7 +106,7 @@ class MEDIA_GPU_EXPORT H264Decoder : public AcceleratedVideoDecoder {
         const H264SliceHeader* slice_hdr,
         const H264Picture::Vector& ref_pic_list0,
         const H264Picture::Vector& ref_pic_list1,
-        const scoped_refptr<H264Picture>& pic,
+        scoped_refptr<H264Picture> pic,
         const uint8_t* data,
         size_t size,
         const std::vector<SubsampleEntry>& subsamples) = 0;
@@ -116,7 +116,7 @@ class MEDIA_GPU_EXPORT H264Decoder : public AcceleratedVideoDecoder {
     // the previous call to SubmitDecode().
     // Returns kOk if successful, kFail if there are errors, or kTryAgain if
     // the accelerator needs additional data before being able to proceed.
-    virtual Status SubmitDecode(const scoped_refptr<H264Picture>& pic) = 0;
+    virtual Status SubmitDecode(scoped_refptr<H264Picture> pic) = 0;
 
     // Schedule output (display) of |pic|. Note that returning from this
     // method does not mean that |pic| has already been outputted (displayed),
@@ -124,7 +124,7 @@ class MEDIA_GPU_EXPORT H264Decoder : public AcceleratedVideoDecoder {
     // as this method was called for them. Decoder may drop its reference
     // to |pic| after calling this method.
     // Return true if successful.
-    virtual bool OutputPicture(const scoped_refptr<H264Picture>& pic) = 0;
+    virtual bool OutputPicture(scoped_refptr<H264Picture> pic) = 0;
 
     // Reset any current state that may be cached in the accelerator, dropping
     // any cached parameters/slices that have not been committed yet.
@@ -234,8 +234,8 @@ class MEDIA_GPU_EXPORT H264Decoder : public AcceleratedVideoDecoder {
   void ConstructReferencePicListsB(const H264SliceHeader* slice_hdr);
 
   // Helper functions for reference list construction, per spec.
-  int PicNumF(const scoped_refptr<H264Picture>& pic);
-  int LongTermPicNumF(const scoped_refptr<H264Picture>& pic);
+  int PicNumF(const H264Picture& pic);
+  int LongTermPicNumF(const H264Picture& pic);
 
   // Perform the reference picture lists' modification (reordering), as
   // specified in spec (8.2.4).

media/gpu/h264_decoder_unittest.cc

@@ -47,8 +47,7 @@ const std::string kHighFrame3 = "bear-320x192-high-frame-3.h264";
 // Checks whether the decrypt config in the picture matches the decrypt config
 // passed to this matcher.
 MATCHER_P(DecryptConfigMatches, decrypt_config, "") {
-  const scoped_refptr<H264Picture>& pic = arg;
-  return pic->decrypt_config()->Matches(*decrypt_config);
+  return arg->decrypt_config()->Matches(*decrypt_config);
 }
 
 MATCHER(SubsampleSizeMatches, "Verify subsample sizes match buffer size") {
@@ -107,7 +106,7 @@ class MockH264Accelerator : public H264Decoder::H264Accelerator {
   MockH264Accelerator() = default;
 
   MOCK_METHOD0(CreateH264Picture, scoped_refptr<H264Picture>());
-  MOCK_METHOD1(SubmitDecode, Status(const scoped_refptr<H264Picture>& pic));
+  MOCK_METHOD1(SubmitDecode, Status(scoped_refptr<H264Picture> pic));
   MOCK_METHOD7(SubmitFrameMetadata,
                Status(const H264SPS* sps,
                       const H264PPS* pps,
@@ -115,17 +114,17 @@ class MockH264Accelerator : public H264Decoder::H264Accelerator {
                       const H264Picture::Vector& ref_pic_listp0,
                       const H264Picture::Vector& ref_pic_listb0,
                       const H264Picture::Vector& ref_pic_listb1,
-                      const scoped_refptr<H264Picture>& pic));
+                      scoped_refptr<H264Picture> pic));
   MOCK_METHOD8(SubmitSlice,
                Status(const H264PPS* pps,
                       const H264SliceHeader* slice_hdr,
                       const H264Picture::Vector& ref_pic_list0,
                       const H264Picture::Vector& ref_pic_list1,
-                      const scoped_refptr<H264Picture>& pic,
+                      scoped_refptr<H264Picture> pic,
                       const uint8_t* data,
                       size_t size,
                       const std::vector<SubsampleEntry>& subsamples));
-  MOCK_METHOD1(OutputPicture, bool(const scoped_refptr<H264Picture>& pic));
+  MOCK_METHOD1(OutputPicture, bool(scoped_refptr<H264Picture> pic));
   MOCK_METHOD2(SetStream,
                Status(base::span<const uint8_t> stream,
                       const DecryptConfig* decrypt_config));
@@ -204,12 +203,11 @@ AcceleratedVideoDecoder::DecodeResult H264DecoderTest::Decode() {
 }
 
 // To have better description on mismatch.
-class WithPocMatcher
-    : public MatcherInterface<const scoped_refptr<H264Picture>&> {
+class WithPocMatcher : public MatcherInterface<scoped_refptr<H264Picture>> {
  public:
   explicit WithPocMatcher(int expected_poc) : expected_poc_(expected_poc) {}
 
-  bool MatchAndExplain(const scoped_refptr<H264Picture>& p,
+  bool MatchAndExplain(scoped_refptr<H264Picture> p,
                        MatchResultListener* listener) const override {
     if (p->pic_order_cnt == expected_poc_)
       return true;
@@ -225,7 +223,7 @@ class WithPocMatcher
   int expected_poc_;
 };
 
-inline Matcher<const scoped_refptr<H264Picture>&> WithPoc(int expected_poc) {
+inline Matcher<scoped_refptr<H264Picture>> WithPoc(int expected_poc) {
   return MakeMatcher(new WithPocMatcher(expected_poc));
 }
 

media/gpu/v4l2/v4l2_h264_accelerator.cc

@@ -76,7 +76,7 @@ void V4L2H264Accelerator::H264DPBToV4L2DPB(
     int index = VIDEO_MAX_FRAME;
     if (!pic->nonexisting) {
       scoped_refptr<V4L2DecodeSurface> dec_surface =
-          H264PictureToV4L2DecodeSurface(pic);
+          H264PictureToV4L2DecodeSurface(pic.get());
       index = dec_surface->GetReferenceID();
       ref_surfaces->push_back(dec_surface);
     }
@@ -99,7 +99,7 @@ H264Decoder::H264Accelerator::Status V4L2H264Accelerator::SubmitFrameMetadata(
     const H264Picture::Vector& ref_pic_listp0,
     const H264Picture::Vector& ref_pic_listb0,
     const H264Picture::Vector& ref_pic_listb1,
-    const scoped_refptr<H264Picture>& pic) {
+    scoped_refptr<H264Picture> pic) {
   struct v4l2_ext_control ctrl;
   std::vector<struct v4l2_ext_control> ctrls;
 
@@ -251,7 +251,7 @@ H264Decoder::H264Accelerator::Status V4L2H264Accelerator::SubmitFrameMetadata(
   ctrls.push_back(ctrl);
 
   scoped_refptr<V4L2DecodeSurface> dec_surface =
-      H264PictureToV4L2DecodeSurface(pic);
+      H264PictureToV4L2DecodeSurface(pic.get());
 
   struct v4l2_ext_controls ext_ctrls;
   memset(&ext_ctrls, 0, sizeof(ext_ctrls));
@@ -282,7 +282,7 @@ H264Decoder::H264Accelerator::Status V4L2H264Accelerator::SubmitSlice(
     const H264SliceHeader* slice_hdr,
     const H264Picture::Vector& ref_pic_list0,
     const H264Picture::Vector& ref_pic_list1,
-    const scoped_refptr<H264Picture>& pic,
+    scoped_refptr<H264Picture> pic,
     const uint8_t* data,
     size_t size,
     const std::vector<SubsampleEntry>& subsamples) {
@@ -384,7 +384,7 @@ H264Decoder::H264Accelerator::Status V4L2H264Accelerator::SubmitSlice(
                                   v4l2_slice_param.ref_pic_list1);
 
   scoped_refptr<V4L2DecodeSurface> dec_surface =
-      H264PictureToV4L2DecodeSurface(pic);
+      H264PictureToV4L2DecodeSurface(pic.get());
 
   v4l2_decode_param_.nal_ref_idc = slice_hdr->nal_ref_idc;
 
@@ -402,9 +402,9 @@ H264Decoder::H264Accelerator::Status V4L2H264Accelerator::SubmitSlice(
 }
 
 H264Decoder::H264Accelerator::Status V4L2H264Accelerator::SubmitDecode(
-    const scoped_refptr<H264Picture>& pic) {
+    scoped_refptr<H264Picture> pic) {
   scoped_refptr<V4L2DecodeSurface> dec_surface =
-      H264PictureToV4L2DecodeSurface(pic);
+      H264PictureToV4L2DecodeSurface(pic.get());
 
   v4l2_decode_param_.num_slices = num_slices_;
   v4l2_decode_param_.idr_pic_flag = pic->idr;
@@ -443,9 +443,9 @@ H264Decoder::H264Accelerator::Status V4L2H264Accelerator::SubmitDecode(
   return Status::kOk;
 }
 
-bool V4L2H264Accelerator::OutputPicture(const scoped_refptr<H264Picture>& pic) {
+bool V4L2H264Accelerator::OutputPicture(scoped_refptr<H264Picture> pic) {
   // TODO(crbug.com/647725): Insert correct color space.
-  surface_handler_->SurfaceReady(H264PictureToV4L2DecodeSurface(pic),
+  surface_handler_->SurfaceReady(H264PictureToV4L2DecodeSurface(pic.get()),
                                  pic->bitstream_id(), pic->visible_rect(),
                                  VideoColorSpace());
   return true;
@@ -458,8 +458,7 @@ void V4L2H264Accelerator::Reset() {
 }
 
 scoped_refptr<V4L2DecodeSurface>
-V4L2H264Accelerator::H264PictureToV4L2DecodeSurface(
-    const scoped_refptr<H264Picture>& pic) {
+V4L2H264Accelerator::H264PictureToV4L2DecodeSurface(H264Picture* pic) {
   V4L2H264Picture* v4l2_pic = pic->AsV4L2H264Picture();
   CHECK(v4l2_pic);
   return v4l2_pic->dec_surface();

media/gpu/v4l2/v4l2_h264_accelerator.h

@@ -36,17 +36,17 @@ class V4L2H264Accelerator : public H264Decoder::H264Accelerator {
                              const H264Picture::Vector& ref_pic_listp0,
                              const H264Picture::Vector& ref_pic_listb0,
                              const H264Picture::Vector& ref_pic_listb1,
-                             const scoped_refptr<H264Picture>& pic) override;
+                             scoped_refptr<H264Picture> pic) override;
   Status SubmitSlice(const H264PPS* pps,
                      const H264SliceHeader* slice_hdr,
                      const H264Picture::Vector& ref_pic_list0,
                      const H264Picture::Vector& ref_pic_list1,
-                     const scoped_refptr<H264Picture>& pic,
+                     scoped_refptr<H264Picture> pic,
                      const uint8_t* data,
                      size_t size,
                      const std::vector<SubsampleEntry>& subsamples) override;
-  Status SubmitDecode(const scoped_refptr<H264Picture>& pic) override;
-  bool OutputPicture(const scoped_refptr<H264Picture>& pic) override;
+  Status SubmitDecode(scoped_refptr<H264Picture> pic) override;
+  bool OutputPicture(scoped_refptr<H264Picture> pic) override;
   void Reset() override;
 
  private:
@@ -61,7 +61,7 @@ class V4L2H264Accelerator : public H264Decoder::H264Accelerator {
       const H264DPB& dpb,
       std::vector<scoped_refptr<V4L2DecodeSurface>>* ref_surfaces);
   scoped_refptr<V4L2DecodeSurface> H264PictureToV4L2DecodeSurface(
-      const scoped_refptr<H264Picture>& pic);
+      H264Picture* pic);
 
   size_t num_slices_;
   V4L2DecodeSurfaceHandler* const surface_handler_;

media/gpu/vaapi/vaapi_h264_accelerator.cc

@@ -72,7 +72,7 @@ Status VaapiH264Accelerator::SubmitFrameMetadata(
     const H264Picture::Vector& ref_pic_listp0,
     const H264Picture::Vector& ref_pic_listb0,
     const H264Picture::Vector& ref_pic_listb1,
-    const scoped_refptr<H264Picture>& pic) {
+    scoped_refptr<H264Picture> pic) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   VAPictureParameterBufferH264 pic_param;
   memset(&pic_param, 0, sizeof(pic_param));
@@ -131,7 +131,7 @@ Status VaapiH264Accelerator::SubmitFrameMetadata(
   pic_param.frame_num = pic->frame_num;
 
   InitVAPicture(&pic_param.CurrPic);
-  FillVAPicture(&pic_param.CurrPic, pic);
+  FillVAPicture(&pic_param.CurrPic, std::move(pic));
 
   // Init reference pictures' array.
   for (int i = 0; i < 16; ++i)
@@ -185,7 +185,7 @@ Status VaapiH264Accelerator::SubmitSlice(
     const H264SliceHeader* slice_hdr,
     const H264Picture::Vector& ref_pic_list0,
     const H264Picture::Vector& ref_pic_list1,
-    const scoped_refptr<H264Picture>& pic,
+    scoped_refptr<H264Picture> pic,
     const uint8_t* data,
     size_t size,
     const std::vector<SubsampleEntry>& subsamples) {
@@ -286,8 +286,7 @@ Status VaapiH264Accelerator::SubmitSlice(
              : Status::kFail;
 }
 
-Status VaapiH264Accelerator::SubmitDecode(
-    const scoped_refptr<H264Picture>& pic) {
+Status VaapiH264Accelerator::SubmitDecode(scoped_refptr<H264Picture> pic) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   const bool success = vaapi_wrapper_->ExecuteAndDestroyPendingBuffers(
@@ -295,8 +294,7 @@ Status VaapiH264Accelerator::SubmitDecode(
   return success ? Status::kOk : Status::kFail;
 }
 
-bool VaapiH264Accelerator::OutputPicture(
-    const scoped_refptr<H264Picture>& pic) {
+bool VaapiH264Accelerator::OutputPicture(scoped_refptr<H264Picture> pic) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   const VaapiH264Picture* vaapi_pic = pic->AsVaapiH264Picture();

media/gpu/vaapi/vaapi_h264_accelerator.h

@@ -33,17 +33,17 @@ class VaapiH264Accelerator : public H264Decoder::H264Accelerator {
                              const H264Picture::Vector& ref_pic_listp0,
                              const H264Picture::Vector& ref_pic_listb0,
                              const H264Picture::Vector& ref_pic_listb1,
-                             const scoped_refptr<H264Picture>& pic) override;
+                             scoped_refptr<H264Picture> pic) override;
   Status SubmitSlice(const H264PPS* pps,
                      const H264SliceHeader* slice_hdr,
                      const H264Picture::Vector& ref_pic_list0,
                      const H264Picture::Vector& ref_pic_list1,
-                     const scoped_refptr<H264Picture>& pic,
+                     scoped_refptr<H264Picture> pic,
                      const uint8_t* data,
                      size_t size,
                      const std::vector<SubsampleEntry>& subsamples) override;
-  Status SubmitDecode(const scoped_refptr<H264Picture>& pic) override;
-  bool OutputPicture(const scoped_refptr<H264Picture>& pic) override;
+  Status SubmitDecode(scoped_refptr<H264Picture> pic) override;
+  bool OutputPicture(scoped_refptr<H264Picture> pic) override;
   void Reset() override;
 
  private:

media/gpu/windows/d3d11_h264_accelerator.cc

@@ -97,7 +97,7 @@ Status D3D11H264Accelerator::SubmitFrameMetadata(
     const H264Picture::Vector& ref_pic_listp0,
     const H264Picture::Vector& ref_pic_listb0,
     const H264Picture::Vector& ref_pic_listb1,
-    const scoped_refptr<H264Picture>& pic) {
+    scoped_refptr<H264Picture> pic) {
   const bool is_encrypted = pic->decrypt_config();
 
   std::unique_ptr<D3D11_VIDEO_DECODER_BEGIN_FRAME_CRYPTO_SESSION> content_key;
@@ -123,13 +123,11 @@ Status D3D11H264Accelerator::SubmitFrameMetadata(
                      pic->decrypt_config()->iv().end());
   }
 
-  scoped_refptr<D3D11H264Picture> our_pic(
-      static_cast<D3D11H264Picture*>(pic.get()));
-
   HRESULT hr;
   for (;;) {
     hr = video_context_->DecoderBeginFrame(
-        video_decoder_.Get(), our_pic->picture->output_view().Get(),
+        video_decoder_.Get(),
+        static_cast<D3D11H264Picture*>(pic.get())->picture->output_view().Get(),
         content_key ? sizeof(*content_key) : 0, content_key.get());
 
     if (hr == E_PENDING || hr == D3DERR_WASSTILLDRAWING) {
@@ -158,8 +156,7 @@ Status D3D11H264Accelerator::SubmitFrameMetadata(
 
   int i = 0;
   for (auto it = dpb.begin(); it != dpb.end(); i++, it++) {
-    scoped_refptr<D3D11H264Picture> our_ref_pic(
-        static_cast<D3D11H264Picture*>(it->get()));
+    D3D11H264Picture* our_ref_pic = static_cast<D3D11H264Picture*>(it->get());
     if (!our_ref_pic->ref)
       continue;
     ref_frame_list_[i].Index7Bits = our_ref_pic->level_;
@@ -305,9 +302,8 @@ void D3D11H264Accelerator::PicParamsFromSliceHeader(
   pic_param->IntraPicFlag = slice_hdr->IsISlice();
 }
 
-void D3D11H264Accelerator::PicParamsFromPic(
-    DXVA_PicParams_H264* pic_param,
-    const scoped_refptr<H264Picture>& pic) {
+void D3D11H264Accelerator::PicParamsFromPic(DXVA_PicParams_H264* pic_param,
+                                            scoped_refptr<H264Picture> pic) {
   pic_param->CurrPic.Index7Bits =
       static_cast<D3D11H264Picture*>(pic.get())->level_;
   pic_param->RefPicFlag = pic->ref;
@@ -330,12 +326,11 @@ Status D3D11H264Accelerator::SubmitSlice(
     const H264SliceHeader* slice_hdr,
     const H264Picture::Vector& ref_pic_list0,
     const H264Picture::Vector& ref_pic_list1,
-    const scoped_refptr<H264Picture>& pic,
+    scoped_refptr<H264Picture> pic,
     const uint8_t* data,
     size_t size,
     const std::vector<SubsampleEntry>& subsamples) {
-  scoped_refptr<D3D11H264Picture> our_pic(
-      static_cast<D3D11H264Picture*>(pic.get()));
+  const bool is_encrypted = pic->decrypt_config();
   DXVA_PicParams_H264 pic_param = {};
   FillPicParamsWithConstants(&pic_param);
 
@@ -343,7 +338,7 @@ Status D3D11H264Accelerator::SubmitSlice(
   if (!PicParamsFromPPS(&pic_param, pps))
     return Status::kFail;
   PicParamsFromSliceHeader(&pic_param, slice_hdr);
-  PicParamsFromPic(&pic_param, pic);
+  PicParamsFromPic(&pic_param, std::move(pic));
 
   memcpy(pic_param.RefFrameList, ref_frame_list_,
          sizeof pic_param.RefFrameList);
@@ -423,8 +418,6 @@ Status D3D11H264Accelerator::SubmitSlice(
   size_t remaining_bitstream = out_bitstream_size;
   size_t start_location = 0;
 
-  const bool is_encrypted = pic->decrypt_config();
-
   if (is_encrypted) {
     // For now, the entire frame has to fit into the bitstream buffer. This way
     // the subsample ClearSize adjustment below should work.
@@ -574,8 +567,7 @@ bool D3D11H264Accelerator::SubmitSliceData() {
   return true;
 }
 
-Status D3D11H264Accelerator::SubmitDecode(
-    const scoped_refptr<H264Picture>& pic) {
+Status D3D11H264Accelerator::SubmitDecode(scoped_refptr<H264Picture> pic) {
   if (!SubmitSliceData()) {
     RecordFailure("SubmitSliceData failed");
     return Status::kFail;
@@ -603,12 +595,10 @@ void D3D11H264Accelerator::Reset() {
   CHECK(SUCCEEDED(hr));
 }
 
-bool D3D11H264Accelerator::OutputPicture(
-    const scoped_refptr<H264Picture>& pic) {
-  scoped_refptr<D3D11H264Picture> our_pic(
-      static_cast<D3D11H264Picture*>(pic.get()));
+bool D3D11H264Accelerator::OutputPicture(scoped_refptr<H264Picture> pic) {
+  D3D11H264Picture* our_pic = static_cast<D3D11H264Picture*>(pic.get());
 
-  client_->OutputResult(pic.get(), our_pic->picture);
+  client_->OutputResult(our_pic, our_pic->picture);
   return true;
 }
 

media/gpu/windows/d3d11_h264_accelerator.h

@@ -49,18 +49,18 @@ class D3D11H264Accelerator : public H264Decoder::H264Accelerator {
                              const H264Picture::Vector& ref_pic_listp0,
                              const H264Picture::Vector& ref_pic_listb0,
                              const H264Picture::Vector& ref_pic_listb1,
-                             const scoped_refptr<H264Picture>& pic) override;
+                             scoped_refptr<H264Picture> pic) override;
   Status SubmitSlice(const H264PPS* pps,
                      const H264SliceHeader* slice_hdr,
                      const H264Picture::Vector& ref_pic_list0,
                      const H264Picture::Vector& ref_pic_list1,
-                     const scoped_refptr<H264Picture>& pic,
+                     scoped_refptr<H264Picture> pic,
                      const uint8_t* data,
                      size_t size,
                      const std::vector<SubsampleEntry>& subsamples) override;
-  Status SubmitDecode(const scoped_refptr<H264Picture>& pic) override;
+  Status SubmitDecode(scoped_refptr<H264Picture> pic) override;
   void Reset() override;
-  bool OutputPicture(const scoped_refptr<H264Picture>& pic) override;
+  bool OutputPicture(scoped_refptr<H264Picture> pic) override;
 
   // Gets a pic params struct with the constant fields set.
   void FillPicParamsWithConstants(DXVA_PicParams_H264* pic_param);
@@ -78,7 +78,7 @@ class D3D11H264Accelerator : public H264Decoder::H264Accelerator {
                                 const H264SliceHeader* pps);
 
   void PicParamsFromPic(DXVA_PicParams_H264* pic_param,
-                        const scoped_refptr<H264Picture>& pic);
+                        scoped_refptr<H264Picture> pic);
 
  private:
   bool SubmitSliceData();