EDK: Sprinkle some more |final| secret sauce.

mojo/edk/util/command_line.h

 // 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.
 
 // Provides a simple class, |CommandLine|, for dealing with command lines (and
 // flags and positional arguments).
 //
 // * Options (a.k.a. flags or switches) are all of the form "--name=<value>" (or
 //   "--name", but this is indistinguishable from "--name="), where <value> is a
 //   string. Not supported: "-name", "-n", "--name <value>", "-n <value>", etc.
@@ skipping 34 matching lines @@
 #include "mojo/public/cpp/system/macros.h"
 
 namespace mojo {
 namespace util {
 
 // CommandLine -----------------------------------------------------------------
 
 // Class that stores processed command lines ("argv[0]", options, and positional
 // arguments) and provides access to them. For more details, see the file-level
 // comment above. This class is thread-safe.
-class CommandLine {
+class CommandLine final {
  private:
   class ConstructionHelper;
 
  public:
   struct Option {
     Option() {}
     explicit Option(const std::string& name);
     Option(const std::string& name, const std::string& value);
 
     bool operator==(const Option& other) const {
@@ skipping 66 matching lines @@
 
   // Allow copy and assignment.
 };
 
 // Factory functions (etc.) ----------------------------------------------------
 
 namespace internal {
 
 // Helper class for building command lines (finding options, etc.) from raw
 // arguments.
-class CommandLineBuilder {
+class CommandLineBuilder final {
  public:
   CommandLineBuilder();
   ~CommandLineBuilder();
 
   // Processes an additional argument in the command line. Returns true if |arg|
   // is the *first* positional argument.
   bool ProcessArg(const std::string& arg);
 
   // Builds a |CommandLine| from the arguments processed so far.
   CommandLine Build() const;
@@ skipping 62 matching lines @@
 
 // This is the "opposite" of the above factory functions, transforming a
 // |CommandLine| into a vector of argument strings according to the rules
 // outlined at the top of this file.
 std::vector<std::string> CommandLineToArgv(const CommandLine& command_line);
 
 }  // namespace util
 }  // namespace mojo
 
 #endif  // MOJO_EDK_UTIL_COMMAND_LINE_H_