media: Change auto to not deduce raw pointers.

media/gpu/vt_video_encode_accelerator_mac.cc

 // Copyright 2016 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 "media/gpu/vt_video_encode_accelerator_mac.h"
 
 #include <memory>
 
 #include "base/threading/thread_task_runner_handle.h"
 #include "media/base/mac/coremedia_glue.h"
@@ skipping 364 matching lines @@
 // static
 void VTVideoEncodeAccelerator::CompressionCallback(void* encoder_opaque,
                                                    void* request_opaque,
                                                    OSStatus status,
                                                    VTEncodeInfoFlags info,
                                                    CMSampleBufferRef sbuf) {
   // This function may be called asynchronously, on a different thread from the
   // one that calls VTCompressionSessionEncodeFrame.
   DVLOG(3) << __FUNCTION__;
 
-  auto encoder = reinterpret_cast<VTVideoEncodeAccelerator*>(encoder_opaque);
+  auto* encoder = reinterpret_cast<VTVideoEncodeAccelerator*>(encoder_opaque);
   DCHECK(encoder);
 
   // InProgressFrameEncode holds timestamp information of the encoded frame.
   std::unique_ptr<InProgressFrameEncode> frame_info(
       reinterpret_cast<InProgressFrameEncode*>(request_opaque));
 
   // EncodeOutput holds onto CMSampleBufferRef when posting task between
   // threads.
   std::unique_ptr<EncodeOutput> encode_output(
       new EncodeOutput(info, sbuf, frame_info->timestamp));
@@ skipping 38 matching lines @@
 
   if (encode_output->info & VideoToolboxGlue::kVTEncodeInfo_FrameDropped) {
     DVLOG(2) << " frame dropped";
     client_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&Client::BitstreamBufferReady, client_, buffer_ref->id, 0,
                    false, encode_output->capture_timestamp));
     return;
   }
 
-  auto sample_attachments = static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(
-      CoreMediaGlue::CMSampleBufferGetSampleAttachmentsArray(
-          encode_output->sample_buffer.get(), true),
-      0));
+  auto* sample_attachments =
+      static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(
+          CoreMediaGlue::CMSampleBufferGetSampleAttachmentsArray(
+              encode_output->sample_buffer.get(), true),
+          0));
   const bool keyframe = !CFDictionaryContainsKey(
       sample_attachments, CoreMediaGlue::kCMSampleAttachmentKey_NotSync());
 
   size_t used_buffer_size = 0;
   const bool copy_rv = video_toolbox::CopySampleBufferToAnnexBBuffer(
       encode_output->sample_buffer.get(), keyframe, buffer_ref->size,
       reinterpret_cast<char*>(buffer_ref->shm->memory()), &used_buffer_size);
   if (!copy_rv) {
     DLOG(ERROR) << "Cannot copy output from SampleBuffer to AnnexBBuffer.";
     used_buffer_size = 0;
@@ skipping 16 matching lines @@
                                  kCVPixelBufferPixelFormatTypeKey};
   const int format[] = {
       CoreVideoGlue::kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange};
   CFTypeRef attributes_values[] = {
       kCFBooleanTrue,
       video_toolbox::DictionaryWithKeysAndValues(nullptr, nullptr, 0).release(),
       video_toolbox::ArrayWithIntegers(format, arraysize(format)).release()};
   const base::ScopedCFTypeRef<CFDictionaryRef> attributes =
       video_toolbox::DictionaryWithKeysAndValues(
           attributes_keys, attributes_values, arraysize(attributes_keys));
-  for (auto& v : attributes_values)
+  for (auto* v : attributes_values)
     CFRelease(v);
 
   bool session_rv =
       CreateCompressionSession(attributes, input_visible_size_, false);
   if (!session_rv) {
     DestroyCompressionSession();
     return false;
   }
 
   const bool configure_rv = ConfigureCompressionSession();
@@ skipping 73 matching lines @@
          (encoder_thread_.IsRunning() &&
           encoder_thread_task_runner_->BelongsToCurrentThread()));
 
   if (compression_session_) {
     videotoolbox_glue_->VTCompressionSessionInvalidate(compression_session_);
     compression_session_.reset();
   }
 }
 
 }  // namespace media