Replacing the OVERRIDE with override in tools folder

tools/gn/parse_tree.h

 // 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.
 
 #ifndef TOOLS_GN_PARSE_TREE_H_
 #define TOOLS_GN_PARSE_TREE_H_
 
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 121 matching lines @@
 // identifier. So you can't do things like:
 //   function_call()[1]
 //   a = b.c.d
 // These are easier to implement if we needed them but given the very limited
 // use cases for this, it hasn't seemed worth the bother.
 class AccessorNode : public ParseNode {
  public:
   AccessorNode();
   virtual ~AccessorNode();
 
-  virtual const AccessorNode* AsAccessor() const OVERRIDE;
-  virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
-  virtual LocationRange GetRange() const OVERRIDE;
+  virtual const AccessorNode* AsAccessor() const override;
+  virtual Value Execute(Scope* scope, Err* err) const override;
+  virtual LocationRange GetRange() const override;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
-      const std::string& help = std::string()) const OVERRIDE;
-  virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+      const std::string& help = std::string()) const override;
+  virtual void Print(std::ostream& out, int indent) const override;
 
   // Base is the thing on the left of the [] or dot, currently always required
   // to be an identifier token.
   const Token& base() const { return base_; }
   void set_base(const Token& b) { base_ = b; }
 
   // Index is the expression inside the []. Will be null if member is set.
   const ParseNode* index() const { return index_.get(); }
   void set_index(scoped_ptr<ParseNode> i) { index_ = i.Pass(); }
 
@@ skipping 16 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(AccessorNode);
 };
 
 // BinaryOpNode ----------------------------------------------------------------
 
 class BinaryOpNode : public ParseNode {
  public:
   BinaryOpNode();
   virtual ~BinaryOpNode();
 
-  virtual const BinaryOpNode* AsBinaryOp() const OVERRIDE;
-  virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
-  virtual LocationRange GetRange() const OVERRIDE;
+  virtual const BinaryOpNode* AsBinaryOp() const override;
+  virtual Value Execute(Scope* scope, Err* err) const override;
+  virtual LocationRange GetRange() const override;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
-      const std::string& help = std::string()) const OVERRIDE;
-  virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+      const std::string& help = std::string()) const override;
+  virtual void Print(std::ostream& out, int indent) const override;
 
   const Token& op() const { return op_; }
   void set_op(const Token& t) { op_ = t; }
 
   const ParseNode* left() const { return left_.get(); }
   void set_left(scoped_ptr<ParseNode> left) {
     left_ = left.Pass();
   }
 
   const ParseNode* right() const { return right_.get(); }
@@ skipping 10 matching lines @@
 };
 
 // BlockNode -------------------------------------------------------------------
 
 class BlockNode : public ParseNode {
  public:
   // Set has_scope if this block introduces a nested scope.
   explicit BlockNode(bool has_scope);
   virtual ~BlockNode();
 
-  virtual const BlockNode* AsBlock() const OVERRIDE;
-  virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
-  virtual LocationRange GetRange() const OVERRIDE;
+  virtual const BlockNode* AsBlock() const override;
+  virtual Value Execute(Scope* scope, Err* err) const override;
+  virtual LocationRange GetRange() const override;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
-      const std::string& help = std::string()) const OVERRIDE;
-  virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+      const std::string& help = std::string()) const override;
+  virtual void Print(std::ostream& out, int indent) const override;
 
   void set_begin_token(const Token& t) { begin_token_ = t; }
   void set_end(scoped_ptr<EndNode> e) { end_ = e.Pass(); }
   const EndNode* End() const { return end_.get(); }
 
   const std::vector<ParseNode*>& statements() const { return statements_; }
   void append_statement(scoped_ptr<ParseNode> s) {
     statements_.push_back(s.release());
   }
 
@@ skipping 14 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(BlockNode);
 };
 
 // ConditionNode ---------------------------------------------------------------
 
 class ConditionNode : public ParseNode {
  public:
   ConditionNode();
   virtual ~ConditionNode();
 
-  virtual const ConditionNode* AsConditionNode() const OVERRIDE;
-  virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
-  virtual LocationRange GetRange() const OVERRIDE;
+  virtual const ConditionNode* AsConditionNode() const override;
+  virtual Value Execute(Scope* scope, Err* err) const override;
+  virtual LocationRange GetRange() const override;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
-      const std::string& help = std::string()) const OVERRIDE;
-  virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+      const std::string& help = std::string()) const override;
+  virtual void Print(std::ostream& out, int indent) const override;
 
   void set_if_token(const Token& token) { if_token_ = token; }
 
   const ParseNode* condition() const { return condition_.get(); }
   void set_condition(scoped_ptr<ParseNode> c) {
     condition_ = c.Pass();
   }
 
   const BlockNode* if_true() const { return if_true_.get(); }
   void set_if_true(scoped_ptr<BlockNode> t) {
@@ skipping 18 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ConditionNode);
 };
 
 // FunctionCallNode ------------------------------------------------------------
 
 class FunctionCallNode : public ParseNode {
  public:
   FunctionCallNode();
   virtual ~FunctionCallNode();
 
-  virtual const FunctionCallNode* AsFunctionCall() const OVERRIDE;
-  virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
-  virtual LocationRange GetRange() const OVERRIDE;
+  virtual const FunctionCallNode* AsFunctionCall() const override;
+  virtual Value Execute(Scope* scope, Err* err) const override;
+  virtual LocationRange GetRange() const override;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
-      const std::string& help = std::string()) const OVERRIDE;
-  virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+      const std::string& help = std::string()) const override;
+  virtual void Print(std::ostream& out, int indent) const override;
 
   const Token& function() const { return function_; }
   void set_function(Token t) { function_ = t; }
 
   const ListNode* args() const { return args_.get(); }
   void set_args(scoped_ptr<ListNode> a) { args_ = a.Pass(); }
 
   const BlockNode* block() const { return block_.get(); }
   void set_block(scoped_ptr<BlockNode> b) { block_ = b.Pass(); }
 
  private:
   Token function_;
   scoped_ptr<ListNode> args_;
   scoped_ptr<BlockNode> block_;  // May be null.
 
   DISALLOW_COPY_AND_ASSIGN(FunctionCallNode);
 };
 
 // IdentifierNode --------------------------------------------------------------
 
 class IdentifierNode : public ParseNode {
  public:
   IdentifierNode();
   IdentifierNode(const Token& token);
   virtual ~IdentifierNode();
 
-  virtual const IdentifierNode* AsIdentifier() const OVERRIDE;
-  virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
-  virtual LocationRange GetRange() const OVERRIDE;
+  virtual const IdentifierNode* AsIdentifier() const override;
+  virtual Value Execute(Scope* scope, Err* err) const override;
+  virtual LocationRange GetRange() const override;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
-      const std::string& help = std::string()) const OVERRIDE;
-  virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+      const std::string& help = std::string()) const override;
+  virtual void Print(std::ostream& out, int indent) const override;
 
   const Token& value() const { return value_; }
   void set_value(const Token& t) { value_ = t; }
 
  private:
   Token value_;
 
   DISALLOW_COPY_AND_ASSIGN(IdentifierNode);
 };
 
 // ListNode --------------------------------------------------------------------
 
 class ListNode : public ParseNode {
  public:
   ListNode();
   virtual ~ListNode();
 
-  virtual const ListNode* AsList() const OVERRIDE;
-  virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
-  virtual LocationRange GetRange() const OVERRIDE;
+  virtual const ListNode* AsList() const override;
+  virtual Value Execute(Scope* scope, Err* err) const override;
+  virtual LocationRange GetRange() const override;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
-      const std::string& help = std::string()) const OVERRIDE;
-  virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+      const std::string& help = std::string()) const override;
+  virtual void Print(std::ostream& out, int indent) const override;
 
   void set_begin_token(const Token& t) { begin_token_ = t; }
   void set_end(scoped_ptr<EndNode> e) { end_ = e.Pass(); }
   const EndNode* End() const { return end_.get(); }
 
   void append_item(scoped_ptr<ParseNode> s) {
     contents_.push_back(s.release());
   }
   const std::vector<const ParseNode*>& contents() const { return contents_; }
 
@@ skipping 10 matching lines @@
 };
 
 // LiteralNode -----------------------------------------------------------------
 
 class LiteralNode : public ParseNode {
  public:
   LiteralNode();
   LiteralNode(const Token& token);
   virtual ~LiteralNode();
 
-  virtual const LiteralNode* AsLiteral() const OVERRIDE;
-  virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
-  virtual LocationRange GetRange() const OVERRIDE;
+  virtual const LiteralNode* AsLiteral() const override;
+  virtual Value Execute(Scope* scope, Err* err) const override;
+  virtual LocationRange GetRange() const override;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
-      const std::string& help = std::string()) const OVERRIDE;
-  virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+      const std::string& help = std::string()) const override;
+  virtual void Print(std::ostream& out, int indent) const override;
 
   const Token& value() const { return value_; }
   void set_value(const Token& t) { value_ = t; }
 
  private:
   Token value_;
 
   DISALLOW_COPY_AND_ASSIGN(LiteralNode);
 };
 
 // UnaryOpNode -----------------------------------------------------------------
 
 class UnaryOpNode : public ParseNode {
  public:
   UnaryOpNode();
   virtual ~UnaryOpNode();
 
-  virtual const UnaryOpNode* AsUnaryOp() const OVERRIDE;
-  virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
-  virtual LocationRange GetRange() const OVERRIDE;
+  virtual const UnaryOpNode* AsUnaryOp() const override;
+  virtual Value Execute(Scope* scope, Err* err) const override;
+  virtual LocationRange GetRange() const override;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
-      const std::string& help = std::string()) const OVERRIDE;
-  virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+      const std::string& help = std::string()) const override;
+  virtual void Print(std::ostream& out, int indent) const override;
 
   const Token& op() const { return op_; }
   void set_op(const Token& t) { op_ = t; }
 
   const ParseNode* operand() const { return operand_.get(); }
   void set_operand(scoped_ptr<ParseNode> operand) {
     operand_ = operand.Pass();
   }
 
  private:
   Token op_;
   scoped_ptr<ParseNode> operand_;
 
   DISALLOW_COPY_AND_ASSIGN(UnaryOpNode);
 };
 
 // BlockCommentNode ------------------------------------------------------------
 
 // This node type is only used for standalone comments (that is, those not
 // specifically attached to another syntax element. The most common of these
 // is a standard header block. This node contains only the last line of such
 // a comment block as the anchor, and other lines of the block comment are
 // hung off of it as Before comments, similar to other syntax elements.
 class BlockCommentNode : public ParseNode {
  public:
   BlockCommentNode();
   virtual ~BlockCommentNode();
 
-  virtual const BlockCommentNode* AsBlockComment() const OVERRIDE;
-  virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
-  virtual LocationRange GetRange() const OVERRIDE;
+  virtual const BlockCommentNode* AsBlockComment() const override;
+  virtual Value Execute(Scope* scope, Err* err) const override;
+  virtual LocationRange GetRange() const override;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
-      const std::string& help = std::string()) const OVERRIDE;
-  virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+      const std::string& help = std::string()) const override;
+  virtual void Print(std::ostream& out, int indent) const override;
 
   const Token& comment() const { return comment_; }
   void set_comment(const Token& t) { comment_ = t; }
 
  private:
   Token comment_;
 
   DISALLOW_COPY_AND_ASSIGN(BlockCommentNode);
 };
 
 // EndNode ---------------------------------------------------------------------
 
 // This node type is used as the end_ object for lists and blocks (rather than
 // just the end ']', '}', or ')' token). This is so that during formatting
 // traversal there is a node that appears at the end of the block to which
 // comments can be attached.
 class EndNode : public ParseNode {
  public:
   EndNode(const Token& token);
   virtual ~EndNode();
 
-  virtual const EndNode* AsEnd() const OVERRIDE;
-  virtual Value Execute(Scope* scope, Err* err) const OVERRIDE;
-  virtual LocationRange GetRange() const OVERRIDE;
+  virtual const EndNode* AsEnd() const override;
+  virtual Value Execute(Scope* scope, Err* err) const override;
+  virtual LocationRange GetRange() const override;
   virtual Err MakeErrorDescribing(
       const std::string& msg,
-      const std::string& help = std::string()) const OVERRIDE;
-  virtual void Print(std::ostream& out, int indent) const OVERRIDE;
+      const std::string& help = std::string()) const override;
+  virtual void Print(std::ostream& out, int indent) const override;
 
   const Token& value() const { return value_; }
   void set_value(const Token& t) { value_ = t; }
 
  private:
   Token value_;
 
   DISALLOW_COPY_AND_ASSIGN(EndNode);
 };
 
 #endif  // TOOLS_GN_PARSE_TREE_H_