Minor ipc_message_util cleanup.

tools/ipc_fuzzer/mutate/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 <stdlib.h>
 #include <iostream>
 #include <string>
 #include <vector>
 
@@ skipping 12 matching lines @@
 const char kEndSwitch[] = "end";
 const char kEndSwitchHelp[] =
     "output messages before |m|th message in file (exclusive).";
 
 const char kHelpSwitch[] = "help";
 const char kHelpSwitchHelp[] =
     "display this message.";
 
 const char kInSwitch[] = "in";
 const char kInSwitchHelp[] =
-    "output only the messages in the specified list.";
+    "output only the messages at the specified positions in the file.";
 
 const char kInvertSwitch[] = "invert";
 const char kInvertSwitchHelp[] =
     "output messages NOT meeting above criteria.";
 
 const char kRegexpSwitch[] = "regexp";
 const char kRegexpSwitchHelp[] =
     "output messages matching regular expression |x|.";
 
 const char kStartSwitch[] = "start";
@@ skipping 51 matching lines @@
       start_index = static_cast<size_t>(temp);
   }
 
   size_t end_index = INT_MAX;
   if (cmd->HasSwitch(kEndSwitch)) {
     int temp = atoi(cmd->GetSwitchValueASCII(kEndSwitch).c_str());
     if (temp > 0)
       end_index = static_cast<size_t>(temp);
   }
 
-  bool has_indices = cmd->HasSwitch(kInSwitch);
-  std::vector<bool> indices;
-
   bool has_regexp = cmd->HasSwitch(kRegexpSwitch);
   RE2 filter_pattern(cmd->GetSwitchValueASCII(kRegexpSwitch));
 
   bool invert = cmd->HasSwitch(kInvertSwitch);
   bool perform_dump = cmd->HasSwitch(kDumpSwitch);
 
   std::vector<base::FilePath::StringType> input_file_names;
   base::FilePath::StringType output_file_name;
   base::SplitString(args[0], ',', &input_file_names);
 
   if (!perform_dump) {
     if (args.size() < 2) {
       usage();
       return EXIT_FAILURE;
     }
     output_file_name = args[1];
   }
 
   ipc_fuzzer::MessageVector input_message_vector;
   for (std::vector<base::FilePath::StringType>::iterator
       it = input_file_names.begin(); it != input_file_names.end(); ++it) {
     ipc_fuzzer::MessageVector message_vector;
     if (!ipc_fuzzer::MessageFile::Read(base::FilePath(*it), &message_vector))
       return EXIT_FAILURE;
     input_message_vector.insert(input_message_vector.end(),
                                 message_vector.begin(), message_vector.end());
     message_vector.weak_clear();
   }
 
+  bool has_indices = cmd->HasSwitch(kInSwitch);
+  std::vector<bool> indices;
+
   if (has_indices) {
     indices.resize(input_message_vector.size(), false);
     std::vector<std::string> index_strings;
     base::SplitString(cmd->GetSwitchValueASCII(kInSwitch), ',', &index_strings);
     for (std::vector<std::string>::iterator it = index_strings.begin();
          it != index_strings.end(); ++it) {
       int index = atoi(it->c_str());
       if (index >= 0 && static_cast<size_t>(index) < indices.size())
         indices[index] = true;
     }
@@ skipping 24 matching lines @@
     }
   } else {
     if (!ipc_fuzzer::MessageFile::Write(
             base::FilePath(output_file_name), output_message_vector)) {
       return EXIT_FAILURE;
     }
   }
 
   return EXIT_SUCCESS;
 }