Update {virtual,override} to follow C++11 style 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 50 matching lines @@
 // TreeNode -------------------------------------------------------------------
 
 template <class NodeType>
 class TreeNode : public TreeModelNode {
  public:
   TreeNode() : parent_(NULL) {}
 
   explicit TreeNode(const base::string16& title)
       : title_(title), parent_(NULL) {}
 
-  virtual ~TreeNode() {}
+  ~TreeNode() override {}
 
   // Adds |node| as a child of this node, at |index|.
   virtual void Add(NodeType* node, int index) {
     DCHECK(node);
     DCHECK_GE(index, 0);
     DCHECK_LE(index, child_count());
     // If |node| has a parent, remove it from its parent.
     NodeType* parent = node->parent_;
     if (parent)
       parent->Remove(node);
@@ skipping 65 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_; }
+  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 37 matching lines @@
 
 // TreeNodeModel --------------------------------------------------------------
 
 // TreeModel implementation intended to be used with TreeNodes.
 template <class NodeType>
 class TreeNodeModel : public TreeModel {
  public:
   // Creates a TreeNodeModel with the specified root node. The root is owned
   // by the TreeNodeModel.
   explicit TreeNodeModel(NodeType* root) : root_(root) {}
-  virtual ~TreeNodeModel() {}
+  virtual ~TreeNodeModel() override {}
 
   NodeType* AsNode(TreeModelNode* model_node) {
     return static_cast<NodeType*>(model_node);
   }
 
   void Add(NodeType* parent, NodeType* node, int index) {
     DCHECK(parent && node);
     parent->Add(node, index);
     NotifyObserverTreeNodesAdded(parent, index, 1);
   }
@@ skipping 18 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 {
+  NodeType* GetRoot() override {
     return root_.get();
   }
 
-  virtual int GetChildCount(TreeModelNode* parent) override {
+  int GetChildCount(TreeModelNode* parent) override {
     DCHECK(parent);
     return AsNode(parent)->child_count();
   }
 
-  virtual NodeType* GetChild(TreeModelNode* parent, int index) override {
+  NodeType* GetChild(TreeModelNode* parent, int index) override {
     DCHECK(parent);
     return AsNode(parent)->GetChild(index);
   }
 
-  virtual int GetIndexOf(TreeModelNode* parent, TreeModelNode* child) override {
+  int GetIndexOf(TreeModelNode* parent, TreeModelNode* child) override {
     DCHECK(parent);
     return AsNode(parent)->GetIndexOf(AsNode(child));
   }
 
-  virtual TreeModelNode* GetParent(TreeModelNode* node) override {
+  TreeModelNode* GetParent(TreeModelNode* node) override {
     DCHECK(node);
     return AsNode(node)->parent();
   }
 
-  virtual void AddObserver(TreeModelObserver* observer) override {
+  void AddObserver(TreeModelObserver* observer) override {
     observer_list_.AddObserver(observer);
   }
 
-  virtual void RemoveObserver(TreeModelObserver* observer) override {
+  void RemoveObserver(TreeModelObserver* observer) override {
     observer_list_.RemoveObserver(observer);
   }
 
-  virtual void SetTitle(TreeModelNode* node,
-                        const base::string16& title) override {
+  void SetTitle(TreeModelNode* node,
+                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_