media: Change auto to not deduce raw pointers.

media/midi/midi_manager.cc

 // Copyright (c) 2013 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/midi/midi_manager.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 171 matching lines @@
     session_thread_runner_->PostTask(
         FROM_HERE, base::Bind(&MidiManager::CompleteInitializationInternal,
                               base::Unretained(this), result));
   }
 }
 
 void MidiManager::AddInputPort(const MidiPortInfo& info) {
   ReportUsage(Usage::INPUT_PORT_ADDED);
   base::AutoLock auto_lock(lock_);
   input_ports_.push_back(info);
-  for (auto client : clients_)
+  for (auto* client : clients_)
     client->AddInputPort(info);
 }
 
 void MidiManager::AddOutputPort(const MidiPortInfo& info) {
   ReportUsage(Usage::OUTPUT_PORT_ADDED);
   base::AutoLock auto_lock(lock_);
   output_ports_.push_back(info);
-  for (auto client : clients_)
+  for (auto* client : clients_)
     client->AddOutputPort(info);
 }
 
 void MidiManager::SetInputPortState(uint32_t port_index, MidiPortState state) {
   base::AutoLock auto_lock(lock_);
   DCHECK_LT(port_index, input_ports_.size());
   input_ports_[port_index].state = state;
-  for (auto client : clients_)
+  for (auto* client : clients_)
     client->SetInputPortState(port_index, state);
 }
 
 void MidiManager::SetOutputPortState(uint32_t port_index, MidiPortState state) {
   base::AutoLock auto_lock(lock_);
   DCHECK_LT(port_index, output_ports_.size());
   output_ports_[port_index].state = state;
-  for (auto client : clients_)
+  for (auto* client : clients_)
     client->SetOutputPortState(port_index, state);
 }
 
 void MidiManager::ReceiveMidiData(uint32_t port_index,
                                   const uint8_t* data,
                                   size_t length,
                                   double timestamp) {
   base::AutoLock auto_lock(lock_);
 
-  for (auto client : clients_)
+  for (auto* client : clients_)
     client->ReceiveMidiData(port_index, data, length, timestamp);
 }
 
 void MidiManager::CompleteInitializationInternal(Result result) {
   TRACE_EVENT0("midi", "MidiManager::CompleteInitialization");
   ReportUsage(Usage::INITIALIZED);
   UMA_HISTOGRAM_ENUMERATION("Media.Midi.InputPorts",
                             static_cast<Sample>(input_ports_.size()),
                             kMaxUmaDevices + 1);
   UMA_HISTOGRAM_ENUMERATION("Media.Midi.OutputPorts",
                             static_cast<Sample>(output_ports_.size()),
                             kMaxUmaDevices + 1);
 
   base::AutoLock auto_lock(lock_);
   DCHECK(clients_.empty());
   DCHECK(!initialized_);
   initialized_ = true;
   result_ = result;
 
-  for (auto client : pending_clients_) {
+  for (auto* client : pending_clients_) {
     if (result_ == Result::OK) {
       AddInitialPorts(client);
       clients_.insert(client);
     }
     client->CompleteStartSession(result_);
   }
   pending_clients_.clear();
 }
 
 void MidiManager::AddInitialPorts(MidiManagerClient* client) {
   lock_.AssertAcquired();
 
   for (const auto& info : input_ports_)
     client->AddInputPort(info);
   for (const auto& info : output_ports_)
     client->AddOutputPort(info);
 }
 
 void MidiManager::ShutdownOnSessionThread() {
   Finalize();
   base::AutoLock auto_lock(lock_);
   finalized_ = true;
 
   // Detach all clients so that they do not call MidiManager methods any more.
-  for (auto client : clients_)
+  for (auto* client : clients_)
     client->Detach();
 }
 
 }  // namespace midi
 }  // namespace media