Remove auto raw pointer deduction from non-linux specific code.

ios/chrome/browser/ui/bookmarks/bookmark_utils_ios.mm

 // Copyright (c) 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.
 
 #import "ios/chrome/browser/ui/bookmarks/bookmark_utils_ios.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
@@ skipping 390 matching lines @@
     const NodeVector& vector,
     std::vector<std::unique_ptr<NodesSection>>& nodesSectionVector) {
   nodesSectionVector.clear();
 
   // Make a localized date formatter.
   base::scoped_nsobject<NSDateFormatter> formatter(
       [[NSDateFormatter alloc] init]);
   [formatter setDateFormat:@"MMMM yyyy"];
   // Segregate nodes by creation date.
   // Nodes that were created in the same month are grouped together.
-  for (auto node : vector) {
+  for (auto* node : vector) {
     base::mac::ScopedNSAutoreleasePool pool;
     base::Time dateAdded = node->date_added();
     base::TimeDelta delta = dateAdded - base::Time::UnixEpoch();
     base::scoped_nsobject<NSDate> date(
         [[NSDate alloc] initWithTimeIntervalSince1970:delta.InSeconds()]);
     NSString* dateString = [formatter stringFromDate:date];
     const std::string timeRepresentation = base::SysNSStringToUTF8(dateString);
 
     BOOL found = NO;
     for (const auto& nodesSection : nodesSectionVector) {
@@ skipping 102 matching lines @@
   }
 
   bookmark_utils_ios::SortFolders(&directDescendants);
 
   auto it = std::find(results->begin(), results->end(), folder);
   DCHECK(it != results->end());
   ++it;
   results->insert(it, directDescendants.begin(), directDescendants.end());
 
   // Recursively perform the operation on each direct descendant.
-  for (auto node : directDescendants)
+  for (auto* node : directDescendants)
     UpdateFoldersFromNode(node, results, obstructions);
 }
 
 void SortFolders(NodeVector* vector) {
   UErrorCode error = U_ZERO_ERROR;
   std::unique_ptr<icu::Collator> collator(icu::Collator::createInstance(error));
   if (U_FAILURE(error))
     collator.reset(NULL);
   std::sort(vector->begin(), vector->end(),
             FolderNodeComparator(collator.get()));
 }
 
 NodeVector VisibleNonDescendantNodes(const NodeSet& obstructions,
                                      bookmarks::BookmarkModel* model) {
   NodeVector results;
 
   NodeVector primaryNodes = PrimaryPermanentNodes(model);
   NodeVector filteredPrimaryNodes;
-  for (auto node : primaryNodes) {
+  for (auto* node : primaryNodes) {
     if (IsObstructed(node, obstructions))
       continue;
 
     filteredPrimaryNodes.push_back(node);
   }
 
   // Copy the results over.
   results = filteredPrimaryNodes;
 
   // Iterate over a static copy of the filtered, root folders.
-  for (auto node : filteredPrimaryNodes)
+  for (auto* node : filteredPrimaryNodes)
     UpdateFoldersFromNode(node, &results, obstructions);
 
   return results;
 }
 
 // Whether |vector1| contains only elements of |vector2| in the same order.
 BOOL IsSubvectorOfNodes(const NodeVector& vector1, const NodeVector& vector2) {
   NodeVector::const_iterator it = vector2.begin();
   // Scan the first vector.
-  for (const auto& node : vector1) {
+  for (auto* node : vector1) {
     // Look for a match in the rest of the second vector. When found, advance
     // the iterator on vector2 to only focus on the remaining part of vector2,
     // so that ordering is verified.
     it = std::find(it, vector2.end(), node);
     if (it == vector2.end())
       return NO;
     // If found in vector2, advance the iterator so that the match is only
     // matched once.
     it++;
   }
@@ skipping 90 matching lines @@
 
   *position = cache.position;
   return YES;
 }
 
 void ClearPositionCache() {
   [[NSUserDefaults standardUserDefaults] removeObjectForKey:kPositionCacheKey];
 }
 
 }  // namespace bookmark_utils_ios