Remove ScopedVector from ios/.

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>
 
 #include "base/hash.h"
 #include "base/i18n/string_compare.h"
 #include "base/mac/bind_objc_block.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/mac/scoped_nsobject.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/user_metrics_action.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "components/query_parser/query_parser.h"
 #include "components/strings/grit/components_strings.h"
 #include "ios/chrome/browser/bookmarks/bookmarks_utils.h"
 #include "ios/chrome/browser/experimental_flags.h"
 #import "ios/chrome/browser/ui/bookmarks/bookmark_collection_cells.h"
 #import "ios/chrome/browser/ui/bookmarks/bookmark_menu_item.h"
@@ skipping 362 matching lines @@
 
   return firstParent;
 }
 
 #pragma mark - Segregation of nodes by time.
 
 NodesSection::NodesSection() {}
 
 NodesSection::~NodesSection() {}
 
-// Sorts NodesSection by their time.
-class NodesSectionComparator : public std::binary_function<const NodesSection*,
-                                                           const NodesSection*,
-                                                           bool> {
- public:
-  // Returns true if |n1| preceeds |n2|.
-  bool operator()(const NodesSection* n1, const NodesSection* n2) {
-    return n1->time > n2->time;
-  }
-};
-
-// Sorts bookmark nodes by their creation time.
-class NodeCreationComparator : public std::binary_function<const BookmarkNode*,
-                                                           const BookmarkNode*,
-                                                           bool> {
- public:
-  // Returns true if |n1| preceeds |n2|.
-  bool operator()(const BookmarkNode* n1, const BookmarkNode* n2) {
-    return n1->date_added() > n2->date_added();
-  }
-};
-
-void segregateNodes(const NodeVector& vector,
-                    ScopedVector<NodesSection>& nodesSectionVector) {
+void segregateNodes(
+    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) {
     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 (NodesSection* nodesSection : nodesSectionVector) {
+    for (const auto& nodesSection : nodesSectionVector) {
       if (nodesSection->timeRepresentation == timeRepresentation) {
         nodesSection->vector.push_back(node);
         found = YES;
         break;
       }
     }
 
     if (found)
       continue;
 
     // No NodesSection found.
-    NodesSection* nodesSection = new NodesSection;
+    auto nodesSection = base::MakeUnique<NodesSection>();
     nodesSection->time = dateAdded;
     nodesSection->timeRepresentation = timeRepresentation;
     nodesSection->vector.push_back(node);
-    nodesSectionVector.push_back(nodesSection);
+    nodesSectionVector.push_back(std::move(nodesSection));
   }
 
   // Sort the NodesSections.
   std::sort(nodesSectionVector.begin(), nodesSectionVector.end(),
-            NodesSectionComparator());
+            [](const std::unique_ptr<NodesSection>& n1,
+               const std::unique_ptr<NodesSection>& n2) {
+              return n1->time > n2->time;
+            });
 
   // For each NodesSection, sort the nodes inside.
-  for (NodesSection* nodesSection : nodesSectionVector)
+  for (const auto& nodesSection : nodesSectionVector) {
     std::sort(nodesSection->vector.begin(), nodesSection->vector.end(),
-              NodeCreationComparator());
+              [](const BookmarkNode* n1, const BookmarkNode* n2) {
+                return n1->date_added() > n2->date_added();
+              });
+  }
 }
 
 #pragma mark - Useful bookmark manipulation.
 
 // Adds all children of |folder| that are not obstructed to |results|. They are
 // placed immediately after |folder|, using a depth-first, then alphabetically
 // ordering. |results| must contain |folder|.
 void UpdateFoldersFromNode(const BookmarkNode* folder,
                            NodeVector* results,
                            const NodeSet& obstructions);
@@ skipping 219 matching lines @@
 
   *position = cache.position;
   return YES;
 }
 
 void ClearPositionCache() {
   [[NSUserDefaults standardUserDefaults] removeObjectForKey:kPositionCacheKey];
 }
 
 }  // namespace bookmark_utils_ios