media: Change auto to not deduce raw pointers.

media/cast/sender/h264_vt_encoder.cc

 // Copyright 2014 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/cast/sender/h264_vt_encoder.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <vector>
@@ skipping 165 matching lines @@
 
   if (operational_status == STATUS_INITIALIZED) {
     // Create the shared video frame factory. It persists for the combined
     // lifetime of the encoder and all video frame factory proxies created by
     // |CreateVideoFrameFactory| that reference it.
     video_frame_factory_ =
         scoped_refptr<VideoFrameFactoryImpl>(new VideoFrameFactoryImpl(
             weak_factory_.GetWeakPtr(), cast_environment_));
 
     // Register for power state changes.
-    auto power_monitor = base::PowerMonitor::Get();
+    auto* power_monitor = base::PowerMonitor::Get();
     if (power_monitor) {
       power_monitor->AddObserver(this);
       VLOG(1) << "Registered for power state changes.";
     } else {
       DLOG(WARNING) << "No power monitor. Process suspension will invalidate "
                        "the encoder.";
     }
   }
 }
 
 H264VideoToolboxEncoder::~H264VideoToolboxEncoder() {
   DestroyCompressionSession();
 
   // If video_frame_factory_ is not null, the encoder registered for power state
   // changes in the ctor and it must now unregister.
   if (video_frame_factory_) {
-    auto power_monitor = base::PowerMonitor::Get();
+    auto* power_monitor = base::PowerMonitor::Get();
     if (power_monitor)
       power_monitor->RemoveObserver(this);
   }
 }
 
 void H264VideoToolboxEncoder::ResetCompressionSession() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Ignore reset requests while power suspended.
   if (power_suspended_)
@@ skipping 32 matching lines @@
                                         kCVBufferPropagatedAttachmentsKey};
   CFTypeRef buffer_attributes_values[] = {
       video_toolbox::ArrayWithIntegers(format, arraysize(format)).release(),
       video_toolbox::DictionaryWithKeysAndValues(
           attachments_keys, attachments_values, arraysize(attachments_keys))
           .release()};
   const base::ScopedCFTypeRef<CFDictionaryRef> buffer_attributes =
       video_toolbox::DictionaryWithKeysAndValues(
           buffer_attributes_keys, buffer_attributes_values,
           arraysize(buffer_attributes_keys));
-  for (auto& v : buffer_attributes_values)
+  for (auto* v : buffer_attributes_values)
     CFRelease(v);
 
   // Create the compression session.
 
   // Note that the encoder object is given to the compression session as the
   // callback context using a raw pointer. The C API does not allow us to use a
   // smart pointer, nor is this encoder ref counted. However, this is still
   // safe, because we 1) we own the compression session and 2) we tear it down
   // safely. When destructing the encoder, the compression session is flushed
   // and invalidated. Internally, VideoToolbox will join all of its threads
@@ skipping 241 matching lines @@
     VLOG(1) << "OnResume: Resetting compression session.";
     ResetCompressionSession();
   }
 }
 
 void H264VideoToolboxEncoder::CompressionCallback(void* encoder_opaque,
                                                   void* request_opaque,
                                                   OSStatus status,
                                                   VTEncodeInfoFlags info,
                                                   CMSampleBufferRef sbuf) {
-  auto encoder = reinterpret_cast<H264VideoToolboxEncoder*>(encoder_opaque);
+  auto* encoder = reinterpret_cast<H264VideoToolboxEncoder*>(encoder_opaque);
   const std::unique_ptr<InProgressFrameEncode> request(
       reinterpret_cast<InProgressFrameEncode*>(request_opaque));
   bool keyframe = false;
   bool has_frame_data = false;
 
   if (status != noErr) {
     DLOG(ERROR) << " encoding failed: " << status;
     encoder->cast_environment_->PostTask(
         CastEnvironment::MAIN, FROM_HERE,
         base::Bind(encoder->status_change_cb_, STATUS_CODEC_RUNTIME_ERROR));
   } else if ((info & VideoToolboxGlue::kVTEncodeInfo_FrameDropped)) {
     DVLOG(2) << " frame dropped";
   } else {
-    auto sample_attachments =
+    auto* sample_attachments =
         static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(
             CoreMediaGlue::CMSampleBufferGetSampleAttachmentsArray(sbuf, true),
             0));
 
     // If the NotSync key is not present, it implies Sync, which indicates a
     // keyframe (at least I think, VT documentation is, erm, sparse). Could
     // alternatively use kCMSampleAttachmentKey_DependsOnOthers == false.
     keyframe = !CFDictionaryContainsKey(
                    sample_attachments,
                    CoreMediaGlue::kCMSampleAttachmentKey_NotSync());
@@ skipping 36 matching lines @@
   encoded_frame->encode_completion_time =
       encoder->cast_environment_->Clock()->NowTicks();
   encoder->cast_environment_->PostTask(
       CastEnvironment::MAIN, FROM_HERE,
       base::Bind(request->frame_encoded_callback,
                  base::Passed(&encoded_frame)));
 }
 
 }  // namespace cast
 }  // namespace media