chrome/utility/safe_browsing: Change auto to not deduce raw pointers.

chrome/utility/safe_browsing/mac/hfs.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/utility/safe_browsing/mac/hfs.h"
 
 #include <libkern/OSByteOrder.h>
 #include <stddef.h>
 #include <sys/stat.h>
 
@@ skipping 494 matching lines @@
   return leaf_records_read_ < header_.leafRecords;
 }
 
 bool HFSBTreeIterator::Next() {
   if (!ReadCurrentLeaf())
     return false;
 
   GetLeafData<uint16_t>();  // keyLength
   auto parent_id = OSSwapBigToHostInt32(*GetLeafData<uint32_t>());
   auto key_string_length = OSSwapBigToHostInt16(*GetLeafData<uint16_t>());
-  auto key_string =
+  auto* key_string =
       reinterpret_cast<uint16_t*>(&leaf_data_[current_leaf_offset_]);
   for (uint16_t i = 0;
        i < key_string_length;
        ++i, current_leaf_offset_ += sizeof(uint16_t)) {
     key_string[i] = OSSwapBigToHostInt16(key_string[i]);
   }
   base::string16 key(key_string, key_string_length);
 
   // Read the record type and then rewind as the field is part of the catalog
   // structure that is read next.
   current_record_.record_type = OSSwapBigToHostInt16(*GetLeafData<int16_t>());
   current_record_.unexported = false;
   current_leaf_offset_ -= sizeof(int16_t);
   switch (current_record_.record_type) {
     case kHFSPlusFolderRecord: {
-      auto folder = GetLeafData<HFSPlusCatalogFolder>();
+      auto* folder = GetLeafData<HFSPlusCatalogFolder>();
       ConvertBigEndian(folder);
       ++leaf_records_read_;
       ++current_leaf_records_read_;
 
       // If this key is unexported, or the parent folder is, then mark the
       // record as such.
       if (IsKeyUnexported(key) ||
           unexported_parents_.find(parent_id) != unexported_parents_.end()) {
         unexported_parents_.insert(folder->folderID);
         current_record_.unexported = true;
       }
 
       // Update the CNID map to construct the path tree.
       if (parent_id != 0) {
         auto parent_name = folder_cnid_map_.find(parent_id);
         if (parent_name != folder_cnid_map_.end())
           key = parent_name->second + kFilePathSeparator + key;
       }
       folder_cnid_map_[folder->folderID] = key;
 
       current_record_.path = key;
       current_record_.folder = folder;
       break;
     }
     case kHFSPlusFileRecord: {
-      auto file = GetLeafData<HFSPlusCatalogFile>();
+      auto* file = GetLeafData<HFSPlusCatalogFile>();
       ConvertBigEndian(file);
       ++leaf_records_read_;
       ++current_leaf_records_read_;
 
       base::string16 path =
           folder_cnid_map_[parent_id] + kFilePathSeparator + key;
       current_record_.path = path;
       current_record_.file = file;
       current_record_.unexported =
           unexported_parents_.find(parent_id) != unexported_parents_.end();
@@ skipping 46 matching lines @@
   if (!SeekToNode(current_leaf_number_)) {
     DLOG(ERROR) << "Failed to seek to node " << current_leaf_number_;
     return false;
   }
 
   if (!stream_->ReadExact(&leaf_data_[0], header_.nodeSize)) {
     DLOG(ERROR) << "Failed to read node " << current_leaf_number_;
     return false;
   }
 
-  auto leaf = reinterpret_cast<BTNodeDescriptor*>(&leaf_data_[0]);
+  auto* leaf = reinterpret_cast<BTNodeDescriptor*>(&leaf_data_[0]);
   ConvertBigEndian(leaf);
   if (leaf->kind != kBTLeafNode) {
     DLOG(ERROR) << "Node " << current_leaf_number_ << " is not a leaf";
     return false;
   }
   current_leaf_ = leaf;
   current_leaf_offset_ = sizeof(BTNodeDescriptor);
   current_leaf_records_read_ = 0;
   read_current_leaf_ = true;
   return true;
@@ skipping 10 matching lines @@
   return object;
 }
 
 bool HFSBTreeIterator::IsKeyUnexported(const base::string16& key) {
   return key == kHFSDirMetadataFolder ||
          key == kHFSMetadataFolder;
 }
 
 }  // namespace dmg
 }  // namespace safe_browsing