Remove ScopedVector from tools/ipc_fuzzer/.

tools/ipc_fuzzer/message_tools/message_util.cc

 // Copyright 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.
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdlib.h>
+
 #include <iostream>
+#include <iterator>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/strings/string_split.h"
 #include "third_party/re2/src/re2/re2.h"
 #include "tools/ipc_fuzzer/message_lib/message_file.h"
 #include "tools/ipc_fuzzer/message_lib/message_names.h"
 
 namespace {
 
@@ skipping 100 matching lines @@
   }
 
   ipc_fuzzer::MessageVector input_message_vector;
   for (const base::FilePath::StringType& name : base::SplitString(
            args[0], base::FilePath::StringType(1, ','),
            base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
     ipc_fuzzer::MessageVector message_vector;
     if (!ipc_fuzzer::MessageFile::Read(base::FilePath(name), &message_vector))
       return EXIT_FAILURE;
     input_message_vector.insert(input_message_vector.end(),
-                                message_vector.begin(), message_vector.end());
-    message_vector.weak_clear();
+                                std::make_move_iterator(message_vector.begin()),
+                                std::make_move_iterator(message_vector.end()));
   }
 
   bool has_indices = cmd->HasSwitch(kInSwitch);
   std::vector<bool> indices;
 
   if (has_indices) {
     indices.resize(input_message_vector.size(), false);
     for (const std::string& cur : base::SplitString(
              cmd->GetSwitchValueASCII(kInSwitch), ",", base::TRIM_WHITESPACE,
              base::SPLIT_WANT_ALL)) {
       int index = atoi(cur.c_str());
       if (index >= 0 && static_cast<size_t>(index) < indices.size())
         indices[index] = true;
     }
   }
 
   ipc_fuzzer::MessageVector output_message_vector;
   std::vector<size_t> remap_vector;
 
   for (size_t i = 0; i < input_message_vector.size(); ++i) {
     bool valid = (i >= start_index && i < end_index);
     if (valid && has_regexp) {
-      valid = MessageMatches(input_message_vector[i], filter_pattern);
+      valid = MessageMatches(input_message_vector[i].get(), filter_pattern);
     }
     if (valid && has_indices) {
       valid = indices[i];
     }
     if (valid != invert) {
-      output_message_vector.push_back(input_message_vector[i]);
+      output_message_vector.push_back(std::move(input_message_vector[i]));
       remap_vector.push_back(i);
-      input_message_vector[i] = NULL;
     }
   }
 
   if (perform_dump) {
     for (size_t i = 0; i < output_message_vector.size(); ++i) {
       std::cout << remap_vector[i] << ". "
-                << MessageName(output_message_vector[i]) << "\n";
+                << MessageName(output_message_vector[i].get()) << "\n";
     }
   } else {
     if (!ipc_fuzzer::MessageFile::Write(
             base::FilePath(output_file_name), output_message_vector)) {
       return EXIT_FAILURE;
     }
   }
 
   return EXIT_SUCCESS;
 }