replace OVERRIDE and FINAL with override and final in ui/

ui/base/models/tree_node_model.h

 // Copyright (c) 2012 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 UI_BASE_MODELS_TREE_NODE_MODEL_H_
 #define UI_BASE_MODELS_TREE_NODE_MODEL_H_
 
 #include <algorithm>
 #include <vector>
 
@@ skipping 136 matching lines @@
     DCHECK(node);
     typename std::vector<NodeType*>::const_iterator i =
         std::find(children_.begin(), children_.end(), node);
     return i != children_.end() ? static_cast<int>(i - children_.begin()) : -1;
   }
 
   // Sets the title of the node.
   virtual void SetTitle(const base::string16& title) { title_ = title; }
 
   // TreeModelNode:
-  virtual const base::string16& GetTitle() const OVERRIDE { return title_; }
+  virtual const base::string16& GetTitle() const override { return title_; }
 
   // Returns true if this == ancestor, or one of this nodes parents is
   // ancestor.
   bool HasAncestor(const NodeType* ancestor) const {
     if (ancestor == this)
       return true;
     if (!ancestor)
       return false;
     return parent_ ? parent_->HasAncestor(ancestor) : false;
   }
@@ skipping 76 matching lines @@
                       TreeNodesRemoved(this, parent, start, count));
   }
 
   void NotifyObserverTreeNodeChanged(TreeModelNode* node) {
     FOR_EACH_OBSERVER(TreeModelObserver,
                       observer_list_,
                       TreeNodeChanged(this, node));
   }
 
   // TreeModel:
-  virtual NodeType* GetRoot() OVERRIDE {
+  virtual NodeType* GetRoot() override {
     return root_.get();
   }
 
-  virtual int GetChildCount(TreeModelNode* parent) OVERRIDE {
+  virtual int GetChildCount(TreeModelNode* parent) override {
     DCHECK(parent);
     return AsNode(parent)->child_count();
   }
 
-  virtual NodeType* GetChild(TreeModelNode* parent, int index) OVERRIDE {
+  virtual NodeType* GetChild(TreeModelNode* parent, int index) override {
     DCHECK(parent);
     return AsNode(parent)->GetChild(index);
   }
 
-  virtual int GetIndexOf(TreeModelNode* parent, TreeModelNode* child) OVERRIDE {
+  virtual int GetIndexOf(TreeModelNode* parent, TreeModelNode* child) override {
     DCHECK(parent);
     return AsNode(parent)->GetIndexOf(AsNode(child));
   }
 
-  virtual TreeModelNode* GetParent(TreeModelNode* node) OVERRIDE {
+  virtual TreeModelNode* GetParent(TreeModelNode* node) override {
     DCHECK(node);
     return AsNode(node)->parent();
   }
 
-  virtual void AddObserver(TreeModelObserver* observer) OVERRIDE {
+  virtual void AddObserver(TreeModelObserver* observer) override {
     observer_list_.AddObserver(observer);
   }
 
-  virtual void RemoveObserver(TreeModelObserver* observer) OVERRIDE {
+  virtual void RemoveObserver(TreeModelObserver* observer) override {
     observer_list_.RemoveObserver(observer);
   }
 
   virtual void SetTitle(TreeModelNode* node,
-                        const base::string16& title) OVERRIDE {
+                        const base::string16& title) override {
     DCHECK(node);
     AsNode(node)->SetTitle(title);
     NotifyObserverTreeNodeChanged(node);
   }
 
  private:
   // The observers.
   ObserverList<TreeModelObserver> observer_list_;
 
   // The root.
   scoped_ptr<NodeType> root_;
 
   DISALLOW_COPY_AND_ASSIGN(TreeNodeModel);
 };
 
 }  // namespace ui
 
 #endif  // UI_BASE_MODELS_TREE_NODE_MODEL_H_