chrome/browser/media: Change auto to not deduce raw pointers.

chrome/browser/media/router/presentation_service_delegate_impl.cc

 // Copyright 2015 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 "chrome/browser/media/router/presentation_service_delegate_impl.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 382 matching lines @@
 
 PresentationFrameManager::~PresentationFrameManager() {
   for (auto& frame : presentation_frames_)
     frame.second->OnPresentationServiceDelegateDestroyed();
 }
 
 void PresentationFrameManager::OnPresentationSessionStarted(
     const RenderFrameHostId& render_frame_host_id,
     const content::PresentationSessionInfo& session,
     const MediaRoute::Id& route_id) {
-  auto presentation_frame = GetOrAddPresentationFrame(render_frame_host_id);
+  auto* presentation_frame = GetOrAddPresentationFrame(render_frame_host_id);
   presentation_frame->OnPresentationSessionStarted(session, route_id);
 }
 
 void PresentationFrameManager::OnDefaultPresentationSessionStarted(
     const PresentationRequest& request,
     const content::PresentationSessionInfo& session,
     const MediaRoute::Id& route_id) {
-  auto presentation_frame =
+  auto* presentation_frame =
       presentation_frames_.get(request.render_frame_host_id());
   if (presentation_frame)
     presentation_frame->OnPresentationSessionStarted(session, route_id);
 
   if (default_presentation_request_ &&
       default_presentation_request_->Equals(request)) {
     default_presentation_started_callback_.Run(session);
   }
 }
 
 const MediaRoute::Id PresentationFrameManager::GetRouteId(
     const RenderFrameHostId& render_frame_host_id,
     const std::string& presentation_id) const {
-  auto presentation_frame = presentation_frames_.get(render_frame_host_id);
+  auto* presentation_frame = presentation_frames_.get(render_frame_host_id);
   return presentation_frame ? presentation_frame->GetRouteId(presentation_id)
                             : "";
 }
 
 const std::vector<MediaRoute::Id> PresentationFrameManager::GetRouteIds(
     const RenderFrameHostId& render_frame_host_id) const {
-  auto presentation_frame = presentation_frames_.get(render_frame_host_id);
+  auto* presentation_frame = presentation_frames_.get(render_frame_host_id);
   return presentation_frame ? presentation_frame->GetRouteIds()
                             : std::vector<MediaRoute::Id>();
 }
 
 bool PresentationFrameManager::SetScreenAvailabilityListener(
     const RenderFrameHostId& render_frame_host_id,
     content::PresentationScreenAvailabilityListener* listener) {
   DCHECK(listener);
-  auto presentation_frame = GetOrAddPresentationFrame(render_frame_host_id);
+  auto* presentation_frame = GetOrAddPresentationFrame(render_frame_host_id);
   return presentation_frame->SetScreenAvailabilityListener(listener);
 }
 
 bool PresentationFrameManager::RemoveScreenAvailabilityListener(
     const RenderFrameHostId& render_frame_host_id,
     content::PresentationScreenAvailabilityListener* listener) {
   DCHECK(listener);
-  auto presentation_frame = presentation_frames_.get(render_frame_host_id);
+  auto* presentation_frame = presentation_frames_.get(render_frame_host_id);
   return presentation_frame &&
          presentation_frame->RemoveScreenAvailabilityListener(listener);
 }
 
 bool PresentationFrameManager::HasScreenAvailabilityListenerForTest(
     const RenderFrameHostId& render_frame_host_id,
     const MediaSource::Id& source_id) const {
-  auto presentation_frame = presentation_frames_.get(render_frame_host_id);
+  auto* presentation_frame = presentation_frames_.get(render_frame_host_id);
   return presentation_frame &&
          presentation_frame->HasScreenAvailabilityListenerForTest(source_id);
 }
 
 void PresentationFrameManager::ListenForConnectionStateChange(
     const RenderFrameHostId& render_frame_host_id,
     const content::PresentationSessionInfo& connection,
     const content::PresentationConnectionStateChangedCallback&
         state_changed_cb) {
-  auto presentation_frame = presentation_frames_.get(render_frame_host_id);
+  auto* presentation_frame = presentation_frames_.get(render_frame_host_id);
   if (presentation_frame) {
     presentation_frame->ListenForConnectionStateChange(connection,
                                                        state_changed_cb);
   }
 }
 
 void PresentationFrameManager::ListenForSessionMessages(
     const RenderFrameHostId& render_frame_host_id,
     const content::PresentationSessionInfo& session,
     const content::PresentationSessionMessageCallback& message_cb) {
@@ skipping 23 matching lines @@
     PresentationRequest request(render_frame_host_id, default_presentation_url,
                                 frame_url);
     default_presentation_started_callback_ = callback;
     SetDefaultPresentationRequest(request);
   }
 }
 
 void PresentationFrameManager::AddDelegateObserver(
     const RenderFrameHostId& render_frame_host_id,
     DelegateObserver* observer) {
-  auto presentation_frame = GetOrAddPresentationFrame(render_frame_host_id);
+  auto* presentation_frame = GetOrAddPresentationFrame(render_frame_host_id);
   presentation_frame->set_delegate_observer(observer);
 }
 
 void PresentationFrameManager::RemoveDelegateObserver(
     const RenderFrameHostId& render_frame_host_id) {
-  auto presentation_frame = presentation_frames_.get(render_frame_host_id);
+  auto* presentation_frame = presentation_frames_.get(render_frame_host_id);
   if (presentation_frame) {
     presentation_frame->set_delegate_observer(nullptr);
     presentation_frames_.erase(render_frame_host_id);
   }
 }
 
 void PresentationFrameManager::AddDefaultPresentationRequestObserver(
     PresentationServiceDelegateImpl::DefaultPresentationRequestObserver*
         observer) {
   default_presentation_request_observers_.AddObserver(observer);
 }
 
 void PresentationFrameManager::RemoveDefaultPresentationRequestObserver(
     PresentationServiceDelegateImpl::DefaultPresentationRequestObserver*
         observer) {
   default_presentation_request_observers_.RemoveObserver(observer);
 }
 
 void PresentationFrameManager::Reset(
     const RenderFrameHostId& render_frame_host_id) {
-  auto presentation_frame = presentation_frames_.get(render_frame_host_id);
+  auto* presentation_frame = presentation_frames_.get(render_frame_host_id);
   if (presentation_frame)
     presentation_frame->Reset();
 
   if (default_presentation_request_ &&
       render_frame_host_id ==
           default_presentation_request_->render_frame_host_id()) {
     ClearDefaultPresentationRequest();
   }
 }
 
 void PresentationFrameManager::RemoveConnection(
     const RenderFrameHostId& render_frame_host_id,
     const MediaRoute::Id& route_id,
     const std::string& presentation_id) {
-  auto presentation_frame = presentation_frames_.get(render_frame_host_id);
+  auto* presentation_frame = presentation_frames_.get(render_frame_host_id);
   if (presentation_frame)
     presentation_frame->RemoveConnection(route_id, presentation_id);
 }
 
 PresentationFrame* PresentationFrameManager::GetOrAddPresentationFrame(
     const RenderFrameHostId& render_frame_host_id) {
   if (!presentation_frames_.contains(render_frame_host_id)) {
     presentation_frames_.add(
         render_frame_host_id,
         std::unique_ptr<PresentationFrame>(new PresentationFrame(
@@ skipping 324 matching lines @@
 bool PresentationServiceDelegateImpl::HasScreenAvailabilityListenerForTest(
     int render_process_id,
     int render_frame_id,
     const MediaSource::Id& source_id) const {
   RenderFrameHostId render_frame_host_id(render_process_id, render_frame_id);
   return frame_manager_->HasScreenAvailabilityListenerForTest(
       render_frame_host_id, source_id);
 }
 
 }  // namespace media_router