Remove ScopedVector from tools/ipc_fuzzer/.

tools/ipc_fuzzer/fuzzer/fuzzer_main.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 <stddef.h>
 #include <stdint.h>
 
 #include <iostream>
 #include <set>
+#include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/strings/string_split.h"
 #include "ipc/ipc_message_macros.h"
 #include "tools/ipc_fuzzer/fuzzer/fuzzer.h"
 #include "tools/ipc_fuzzer/fuzzer/generator.h"
 #include "tools/ipc_fuzzer/fuzzer/mutator.h"
 #include "tools/ipc_fuzzer/fuzzer/rand_util.h"
 #include "tools/ipc_fuzzer/message_lib/message_file.h"
@@ skipping 66 matching lines @@
       return new Mutator(frequency);
 
     if (name == "no-op")
       return new NoOpFuzzer();
 
     std::cerr << "No such fuzzer: " << name << "\n";
     return 0;
   }
 };
 
-static IPC::Message* RewriteMessage(
-    IPC::Message* message,
-    Fuzzer* fuzzer,
-    FuzzerFunctionMap* map) {
+static std::unique_ptr<IPC::Message> RewriteMessage(IPC::Message* message,
+                                                    Fuzzer* fuzzer,
+                                                    FuzzerFunctionMap* map) {
   FuzzerFunctionMap::iterator it = map->find(message->type());
   if (it == map->end()) {
     // This usually indicates a missing message file in all_messages.h, or
     // that the message dump file is taken from a different revision of
     // chromium from this executable.
     std::cerr << "Unknown message type: ["
               << IPC_MESSAGE_ID_CLASS(message->type()) << ", "
               << IPC_MESSAGE_ID_LINE(message->type()) << "].\n";
     return 0;
   }
@@ skipping 11 matching lines @@
 
   int message_count = 1000;
   if (cmd->HasSwitch(kCountSwitch))
     message_count = atoi(cmd->GetSwitchValueASCII(kCountSwitch).c_str());
 
   MessageVector message_vector;
   int bad_count = 0;
   if (message_count < 0) {
     // Enumerate them all.
     for (size_t i = 0; i < g_function_vector.size(); ++i) {
-      if (IPC::Message* new_message = (*g_function_vector[i])(NULL, fuzzer))
-        message_vector.push_back(new_message);
+      std::unique_ptr<IPC::Message> new_message =
+          (*g_function_vector[i])(nullptr, fuzzer);
+      if (new_message)
+        message_vector.push_back(std::move(new_message));
       else
         bad_count += 1;
     }
   } else {
     // Fuzz a random batch.
     for (int i = 0; i < message_count; ++i) {
       size_t index = RandInRange(g_function_vector.size());
-      if (IPC::Message* new_message = (*g_function_vector[index])(NULL, fuzzer))
-        message_vector.push_back(new_message);
+      std::unique_ptr<IPC::Message> new_message =
+          (*g_function_vector[index])(nullptr, fuzzer);
+      if (new_message)
+        message_vector.push_back(std::move(new_message));
       else
         bad_count += 1;
     }
   }
 
   std::cerr << "Failed to generate " << bad_count << " messages.\n";
   if (!MessageFile::Write(base::FilePath(output_file_name), message_vector))
     return EXIT_FAILURE;
   return EXIT_SUCCESS;
 }
@@ skipping 18 matching lines @@
   }
 
   FuzzerFunctionMap fuzz_function_map;
   PopulateFuzzerFunctionMap(&fuzz_function_map);
 
   MessageVector message_vector;
   if (!MessageFile::Read(base::FilePath(input_file_name), &message_vector))
     return EXIT_FAILURE;
 
   for (size_t i = 0; i < message_vector.size(); ++i) {
-    IPC::Message* msg = message_vector[i];
+    IPC::Message* msg = message_vector[i].get();
     // If an explicit type set is specified, make sure we should be mutating
     // this message type on this run.
     if (!type_set.empty() && type_set.end() == std::find(
             type_set.begin(), type_set.end(), msg->type())) {
       continue;
     }
-    IPC::Message* new_message = RewriteMessage(msg, fuzzer, &fuzz_function_map);
-    if (new_message) {
-      IPC::Message* old_message = message_vector[i];
-      delete old_message;
-      message_vector[i] = new_message;
-    }
+    std::unique_ptr<IPC::Message> new_message =
+        RewriteMessage(msg, fuzzer, &fuzz_function_map);
+    if (new_message)
+      message_vector[i] = std::move(new_message);
   }
 
   if (permute) {
     std::random_shuffle(message_vector.begin(), message_vector.end(),
                         RandInRange);
   }
 
   if (!MessageFile::Write(base::FilePath(output_file_name), message_vector))
     return EXIT_FAILURE;
   return EXIT_SUCCESS;
@@ skipping 36 matching lines @@
   }
 
   return result;
 }
 
 }  // namespace ipc_fuzzer
 
 int main(int argc, char** argv) {
   return ipc_fuzzer::FuzzerMain(argc, argv);
 }