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

chrome/browser/memory/tab_manager.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 "chrome/browser/memory/tab_manager.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <set>
@@ skipping 98 matching lines @@
     }
   }
 
   return -1;
 }
 
 // A wrapper around base::MemoryPressureMonitor::GetCurrentPressureLevel.
 // TODO(chrisha): Move this do the default implementation of a delegate.
 base::MemoryPressureListener::MemoryPressureLevel
 GetCurrentPressureLevel() {
-  auto monitor = base::MemoryPressureMonitor::Get();
+  auto* monitor = base::MemoryPressureMonitor::Get();
   if (monitor)
     return monitor->GetCurrentPressureLevel();
   return base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE;
 }
 
 // A wrapper to content::SendPressureNotification that doesn't have overloaded
 // type ambiguity. Makes use of Bind easier.
 // TODO(chrisha): Move this do the default implementation of a delegate.
 void NotifyRendererProcess(
     const content::RenderProcessHost* render_process_host,
@@ skipping 106 matching lines @@
   auto tab_stats = GetTabStats();
 
   std::vector<content::RenderProcessHost*> sorted_renderers;
   std::set<content::RenderProcessHost*> seen_renderers;
   std::set<content::RenderProcessHost*> visible_renderers;
   sorted_renderers.reserve(tab_stats.size());
 
   // Convert the tab sort order to a process sort order. The process inherits
   // the priority of its highest priority tab.
   for (auto& tab : tab_stats) {
-    auto renderer = tab.render_process_host;
+    auto* renderer = tab.render_process_host;
 
     // Skip renderers associated with visible tabs as handling memory pressure
     // notifications in these processes can cause jank. This code works because
     // visible tabs always come first in |tab_stats|.
     if (tab.is_selected) {
       visible_renderers.insert(renderer);
       continue;
     }
     if (visible_renderers.count(renderer) > 0)
       continue;
@@ skipping 50 matching lines @@
 
 void TabManager::set_test_tick_clock(base::TickClock* test_tick_clock) {
   test_tick_clock_ = test_tick_clock;
 }
 
 void TabManager::TabChangedAt(content::WebContents* contents,
                               int index,
                               TabChangeType change_type) {
   if (change_type != TabChangeType::ALL)
     return;
-  auto data = GetWebContentsData(contents);
+  auto* data = GetWebContentsData(contents);
   bool old_state = data->IsRecentlyAudible();
   bool current_state = contents->WasRecentlyAudible();
   if (old_state != current_state) {
     data->SetRecentlyAudible(current_state);
     data->SetLastAudioChangeTime(NowTicks());
   }
 }
 
 void TabManager::ActiveTabChanged(content::WebContents* old_contents,
                                   content::WebContents* new_contents,
@@ skipping 386 matching lines @@
     return true;
   }
 
   auto delta = NowTicks() - GetWebContentsData(contents)->LastAudioChangeTime();
   return delta < TimeDelta::FromSeconds(kAudioProtectionTimeSeconds);
 }
 
 TabManager::WebContentsData* TabManager::GetWebContentsData(
     content::WebContents* contents) const {
   WebContentsData::CreateForWebContents(contents);
-  auto web_contents_data = WebContentsData::FromWebContents(contents);
+  auto* web_contents_data = WebContentsData::FromWebContents(contents);
   web_contents_data->set_test_tick_clock(test_tick_clock_);
   return web_contents_data;
 }
 
 // static
 bool TabManager::CompareTabStats(const TabStats& first,
                                  const TabStats& second) {
   // Being currently selected is most important to protect.
   if (first.is_selected != second.is_selected)
     return first.is_selected;
@@ skipping 190 matching lines @@
 bool TabManager::IsTabAutoDiscardable(content::WebContents* contents) const {
   return GetWebContentsData(contents)->IsAutoDiscardable();
 }
 
 void TabManager::SetTabAutoDiscardableState(content::WebContents* contents,
                                             bool state) {
   GetWebContentsData(contents)->SetAutoDiscardableState(state);
 }
 
 }  // namespace memory