Remove implicit conversions from scoped_refptr to T* in content/

content/common/gpu/media/dxva_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/dxva_video_decode_accelerator.h"
 
 #if !defined(OS_WIN)
 #error This file should only be built on Windows.
 #endif   // !defined(OS_WIN)
 
@@ skipping 78 matching lines @@
     // Note that MFCreateMemoryBuffer is same as MFCreateAlignedMemoryBuffer
     // with the align argument being 0.
     hr = MFCreateMemoryBuffer(buffer_length, buffer.Receive());
   } else {
     hr = MFCreateAlignedMemoryBuffer(buffer_length,
                                      align - 1,
                                      buffer.Receive());
   }
   RETURN_ON_HR_FAILURE(hr, "Failed to create memory buffer for sample", NULL);
 
-  hr = sample->AddBuffer(buffer);
+  hr = sample->AddBuffer(buffer.get());
   RETURN_ON_HR_FAILURE(hr, "Failed to add buffer to sample", NULL);
 
   return sample.Detach();
 }
 
 // Creates a Media Foundation sample with one buffer containing a copy of the
 // given Annex B stream data.
 // If duration and sample time are not known, provide 0.
 // |min_size| specifies the minimum size of the buffer (might be required by
 // the decoder for input). If no alignment is required, provide 0.
 static IMFSample* CreateInputSample(const uint8* stream, int size,
                                     int min_size, int alignment) {
   CHECK(stream);
   CHECK_GT(size, 0);
   base::win::ScopedComPtr<IMFSample> sample;
   sample.Attach(CreateEmptySampleWithBuffer(std::max(min_size, size),
                                             alignment));
-  RETURN_ON_FAILURE(sample, "Failed to create empty sample", NULL);
+  RETURN_ON_FAILURE(sample.get(), "Failed to create empty sample", NULL);
 
   base::win::ScopedComPtr<IMFMediaBuffer> buffer;
   HRESULT hr = sample->GetBufferByIndex(0, buffer.Receive());
   RETURN_ON_HR_FAILURE(hr, "Failed to get buffer from sample", NULL);
 
   DWORD max_length = 0;
   DWORD current_length = 0;
   uint8* destination = NULL;
   hr = buffer->Lock(&destination, &max_length, &current_length);
   RETURN_ON_HR_FAILURE(hr, "Failed to lock buffer", NULL);
@@ skipping 194 matching lines @@
   glGetIntegerv(GL_TEXTURE_BINDING_2D, &current_texture);
 
   glBindTexture(GL_TEXTURE_2D, picture_buffer_.texture_id());
 
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 
   base::win::ScopedComPtr<IDirect3DSurface9> d3d_surface;
   hr = decoding_texture_->GetSurfaceLevel(0, d3d_surface.Receive());
   RETURN_ON_HR_FAILURE(hr, "Failed to get surface from texture", false);
 
-  hr = decoder.device_->StretchRect(
-      dest_surface, NULL, d3d_surface, NULL, D3DTEXF_NONE);
+  hr = decoder.device_->StretchRect(dest_surface, NULL, d3d_surface.get(), NULL,

[nasko, 2014/11/12 23:18:24]

nit: The params all fit on one line, so not sure why clang-format split them
like this.

[dcheng, 2014/11/12 23:22:49]

I'm pretty sure this is because we recently changed how clang-format prefers to
pack arguments at the call site =/

I don't really have a strong opinion here other than I'd prefer to avoid
fighting against clang-format. =)

+                                    D3DTEXF_NONE);
   RETURN_ON_HR_FAILURE(hr, "Colorspace conversion via StretchRect failed",
                         false);
 
   // Ideally, this should be done immediately before the draw call that uses
   // the texture. Flush it once here though.
   hr = decoder.query_->Issue(D3DISSUE_END);
   RETURN_ON_HR_FAILURE(hr, "Failed to issue END", false);
 
   // The DXVA decoder has its own device which it uses for decoding. ANGLE
   // has its own device which we don't have access to.
@@ skipping 59 matching lines @@
                              D3DCREATE_MULTITHREADED,
                              &present_params,
                              NULL,
                              device_.Receive());
   RETURN_ON_HR_FAILURE(hr, "Failed to create D3D device", false);
 
   hr = DXVA2CreateDirect3DDeviceManager9(&dev_manager_reset_token_,
                                          device_manager_.Receive());
   RETURN_ON_HR_FAILURE(hr, "DXVA2CreateDirect3DDeviceManager9 failed", false);
 
-  hr = device_manager_->ResetDevice(device_, dev_manager_reset_token_);
+  hr = device_manager_->ResetDevice(device_.get(), dev_manager_reset_token_);
   RETURN_ON_HR_FAILURE(hr, "Failed to reset device", false);
 
   hr = device_->CreateQuery(D3DQUERYTYPE_EVENT, query_.Receive());
   RETURN_ON_HR_FAILURE(hr, "Failed to create D3D device query", false);
   // Ensure query_ API works (to avoid an infinite loop later in
   // CopyOutputSampleDataToPictureBuffer).
   hr = query_->Issue(D3DISSUE_END);
   RETURN_ON_HR_FAILURE(hr, "Failed to issue END test query", false);
   return true;
 }
@@ skipping 82 matching lines @@
   DCHECK(CalledOnValidThread());
 
   RETURN_AND_NOTIFY_ON_FAILURE((state_ == kNormal || state_ == kStopped ||
                                 state_ == kFlushing),
       "Invalid state: " << state_, ILLEGAL_STATE,);
 
   base::win::ScopedComPtr<IMFSample> sample;
   sample.Attach(CreateSampleFromInputBuffer(bitstream_buffer,
                                             input_stream_info_.cbSize,
                                             input_stream_info_.cbAlignment));
-  RETURN_AND_NOTIFY_ON_FAILURE(sample, "Failed to create input sample",
-                               PLATFORM_FAILURE,);
+  RETURN_AND_NOTIFY_ON_FAILURE(sample.get(), "Failed to create input sample",
+                               PLATFORM_FAILURE, );

[nasko, 2014/11/12 23:18:24]

nit: Do we really need the extra space after ","? It isn't present in the rest
of the macros.

[dcheng, 2014/11/12 23:22:49]

Would prefer to avoid fighting clang-format here too. Frankly, I think it's ugly
either way.

 
   RETURN_AND_NOTIFY_ON_HR_FAILURE(sample->SetSampleTime(bitstream_buffer.id()),
       "Failed to associate input buffer id with sample", PLATFORM_FAILURE,);
 
   DecodeInternal(sample);
 }
 
 void DXVAVideoDecodeAccelerator::AssignPictureBuffers(
     const std::vector<media::PictureBuffer>& buffers) {
   DCHECK(CalledOnValidThread());
@@ skipping 218 matching lines @@
 
   hr = media_type->SetGUID(MF_MT_SUBTYPE, MFVideoFormat_H264);
   RETURN_ON_HR_FAILURE(hr, "Failed to set subtype", false);
 
   // Not sure about this. msdn recommends setting this value on the input
   // media type.
   hr = media_type->SetUINT32(MF_MT_INTERLACE_MODE,
                              MFVideoInterlace_MixedInterlaceOrProgressive);
   RETURN_ON_HR_FAILURE(hr, "Failed to set interlace mode", false);
 
-  hr = decoder_->SetInputType(0, media_type, 0);  // No flags
+  hr = decoder_->SetInputType(0, media_type.get(), 0);  // No flags
   RETURN_ON_HR_FAILURE(hr, "Failed to set decoder input type", false);
   return true;
 }
 
 bool DXVAVideoDecodeAccelerator::SetDecoderOutputMediaType(
     const GUID& subtype) {
   base::win::ScopedComPtr<IMFMediaType> out_media_type;
 
   for (uint32 i = 0;
        SUCCEEDED(decoder_->GetOutputAvailableType(0, i,
                                                   out_media_type.Receive()));
        ++i) {
     GUID out_subtype = {0};
     HRESULT hr = out_media_type->GetGUID(MF_MT_SUBTYPE, &out_subtype);
     RETURN_ON_HR_FAILURE(hr, "Failed to get output major type", false);
 
     if (out_subtype == subtype) {
-      hr = decoder_->SetOutputType(0, out_media_type, 0);  // No flags
+      hr = decoder_->SetOutputType(0, out_media_type.get(), 0);  // No flags
       RETURN_ON_HR_FAILURE(hr, "Failed to set decoder output type", false);
       return true;
     }
     out_media_type.Release();
   }
   return false;
 }
 
 bool DXVAVideoDecodeAccelerator::SendMFTMessage(MFT_MESSAGE_TYPE msg,
                                                 int32 param) {
@@ skipping 89 matching lines @@
 }
 
 bool DXVAVideoDecodeAccelerator::ProcessOutputSample(IMFSample* sample) {
   RETURN_ON_FAILURE(sample, "Decode succeeded with NULL output sample", false);
 
   base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
   HRESULT hr = sample->GetBufferByIndex(0, output_buffer.Receive());
   RETURN_ON_HR_FAILURE(hr, "Failed to get buffer from output sample", false);
 
   base::win::ScopedComPtr<IDirect3DSurface9> surface;
-  hr = MFGetService(output_buffer, MR_BUFFER_SERVICE,
+  hr = MFGetService(output_buffer.get(), MR_BUFFER_SERVICE,
                     IID_PPV_ARGS(surface.Receive()));
   RETURN_ON_HR_FAILURE(hr, "Failed to get D3D surface from output sample",
                        false);
 
   LONGLONG input_buffer_id = 0;
   RETURN_ON_HR_FAILURE(sample->GetSampleTime(&input_buffer_id),
                        "Failed to get input buffer id associated with sample",
                        false);
 
   pending_output_samples_.push_back(
@@ skipping 42 matching lines @@
     if (index->second->available()) {
       PendingSampleInfo sample_info = pending_output_samples_.front();
 
       base::win::ScopedComPtr<IMFMediaBuffer> output_buffer;
       HRESULT hr = sample_info.output_sample->GetBufferByIndex(
           0, output_buffer.Receive());
       RETURN_AND_NOTIFY_ON_HR_FAILURE(
           hr, "Failed to get buffer from output sample", PLATFORM_FAILURE,);
 
       base::win::ScopedComPtr<IDirect3DSurface9> surface;
-      hr = MFGetService(output_buffer, MR_BUFFER_SERVICE,
+      hr = MFGetService(output_buffer.get(), MR_BUFFER_SERVICE,
                         IID_PPV_ARGS(surface.Receive()));
       RETURN_AND_NOTIFY_ON_HR_FAILURE(
           hr, "Failed to get D3D surface from output sample",
           PLATFORM_FAILURE,);
 
       D3DSURFACE_DESC surface_desc;
       hr = surface->GetDesc(&surface_desc);
       RETURN_AND_NOTIFY_ON_HR_FAILURE(
           hr, "Failed to get surface description", PLATFORM_FAILURE,);
 
       if (surface_desc.Width !=
               static_cast<uint32>(index->second->size().width()) ||
           surface_desc.Height !=
               static_cast<uint32>(index->second->size().height())) {
         HandleResolutionChanged(surface_desc.Width, surface_desc.Height);
         return;
       }
 
       RETURN_AND_NOTIFY_ON_FAILURE(
-          index->second->CopyOutputSampleDataToPictureBuffer(*this, surface),
-          "Failed to copy output sample",
-          PLATFORM_FAILURE, );
+          index->second->CopyOutputSampleDataToPictureBuffer(*this,
+                                                             surface.get()),
+          "Failed to copy output sample", PLATFORM_FAILURE, );
 
       media::Picture output_picture(index->second->id(),
                                     sample_info.input_buffer_id,
                                     gfx::Rect(index->second->size()));
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(&DXVAVideoDecodeAccelerator::NotifyPictureReady,
                      weak_this_factory_.GetWeakPtr(),
                      output_picture));
 
@@ skipping 128 matching lines @@
   if (!pending_output_samples_.empty() || !pending_input_buffers_.empty()) {
     pending_input_buffers_.push_back(sample);
     return;
   }
 
   if (!inputs_before_decode_) {
     TRACE_EVENT_BEGIN_ETW("DXVAVideoDecodeAccelerator.Decoding", this, "");
   }
   inputs_before_decode_++;
 
-  HRESULT hr = decoder_->ProcessInput(0, sample, 0);
+  HRESULT hr = decoder_->ProcessInput(0, sample.get(), 0);
   // As per msdn if the decoder returns MF_E_NOTACCEPTING then it means that it
   // has enough data to produce one or more output samples. In this case the
   // recommended options are to
   // 1. Generate new output by calling IMFTransform::ProcessOutput until it
   //    returns MF_E_TRANSFORM_NEED_MORE_INPUT.
   // 2. Flush the input data
   // We implement the first option, i.e to retrieve the output sample and then
   // process the input again. Failure in either of these steps is treated as a
   // decoder failure.
   if (hr == MF_E_NOTACCEPTING) {
     DoDecode();
     RETURN_AND_NOTIFY_ON_FAILURE((state_ == kStopped || state_ == kNormal),
         "Failed to process output. Unexpected decoder state: " << state_,
         PLATFORM_FAILURE,);
-    hr = decoder_->ProcessInput(0, sample, 0);
+    hr = decoder_->ProcessInput(0, sample.get(), 0);
     // If we continue to get the MF_E_NOTACCEPTING error we do the following:-
     // 1. Add the input sample to the pending queue.
     // 2. If we don't have any output samples we post the
     //    DecodePendingInputBuffers task to process the pending input samples.
     //    If we have an output sample then the above task is posted when the
     //    output samples are sent to the client.
     // This is because we only support 1 pending output sample at any
     // given time due to the limitation with the Microsoft media foundation
     // decoder where it recycles the output Decoder surfaces.
     if (hr == MF_E_NOTACCEPTING) {
@@ skipping 74 matching lines @@
     int32 picture_buffer_id) {
   OutputBuffers::iterator it = stale_output_picture_buffers_.find(
       picture_buffer_id);
   DCHECK(it != stale_output_picture_buffers_.end());
   DVLOG(1) << "Dismissing picture id: " << it->second->id();
   client_->DismissPictureBuffer(it->second->id());
   stale_output_picture_buffers_.erase(it);
 }
 
 }  // namespace content