Standardize usage of virtual/override/final specifiers.

The Google C++ style guide states:

  Explicitly annotate overrides of virtual functions or virtual
  destructors with an override or (less frequently) final specifier.
  Older (pre-C++11) code will use the virtual keyword as an inferior
  alternative annotation. For clarity, use exactly one of override,
  final, or virtual when declaring an override.

To better conform to these guidelines, the following constructs have
been rewritten:

- if a base class has a virtual destructor, then:
    virtual ~Foo();                   ->  ~Foo() override;
- virtual void Foo() override;        ->  void Foo() override;
- virtual void Foo() override final;  ->  void Foo() final;

This patch was automatically generated. The clang plugin can generate
fixit hints, which are suggested edits when it is 100% sure it knows how
to fix a problem. The hints from the clang plugin were applied to the
source tree using the tool in https://codereview.chromium.org/598073004.

BUG=417463
R=sky@chromium.org

Review URL: https://codereview.chromium.org/670923003

Cr-Commit-Position: refs/heads/master@{#301914}

51 files changed, 466 insertions, 524 deletions

diff --git a/ui/accessibility/ax_tree_serializer_unittest.cc b/ui/accessibility/ax_tree_serializer_unittest.cc
index a0c0fb7..691c0fb 100644
--- a/ui/accessibility/ax_tree_serializer_unittest.cc
+++ b/ui/accessibility/ax_tree_serializer_unittest.cc
@@ -21,7 +21,7 @@ namespace ui {
 class AXTreeSerializerTest : public testing::Test {
  public:
   AXTreeSerializerTest() {}
-  virtual ~AXTreeSerializerTest() {}
+  ~AXTreeSerializerTest() override {}
 
  protected:
   void CreateTreeSerializer();
diff --git a/ui/base/accelerators/accelerator_manager_unittest.cc b/ui/base/accelerators/accelerator_manager_unittest.cc
index ec5a47b..1c3402d7 100644
--- a/ui/base/accelerators/accelerator_manager_unittest.cc
+++ b/ui/base/accelerators/accelerator_manager_unittest.cc
@@ -55,7 +55,7 @@ Accelerator GetAccelerator(KeyboardCode code, int mask) {
 class AcceleratorManagerTest : public testing::Test {
  public:
   AcceleratorManagerTest() {}
-  virtual ~AcceleratorManagerTest() {}
+  ~AcceleratorManagerTest() override {}
 
   AcceleratorManager manager_;
 };
diff --git a/ui/base/clipboard/clipboard_aurax11.cc b/ui/base/clipboard/clipboard_aurax11.cc
index b12c696..1fef1ad 100644
--- a/ui/base/clipboard/clipboard_aurax11.cc
+++ b/ui/base/clipboard/clipboard_aurax11.cc
@@ -74,11 +74,11 @@ class SelectionChangeObserver : public ui::PlatformEventObserver {
   friend struct DefaultSingletonTraits<SelectionChangeObserver>;
 
   SelectionChangeObserver();
-  virtual ~SelectionChangeObserver();
+  ~SelectionChangeObserver() override;
 
   // ui::PlatformEventObserver:
-  virtual void WillProcessEvent(const ui::PlatformEvent& event) override;
-  virtual void DidProcessEvent(const ui::PlatformEvent& event) override {}
+  void WillProcessEvent(const ui::PlatformEvent& event) override;
+  void DidProcessEvent(const ui::PlatformEvent& event) override {}
 
   int event_base_;
   Atom clipboard_atom_;
@@ -229,7 +229,7 @@ bool Clipboard::FormatType::Equals(const FormatType& other) const {
 class ClipboardAuraX11::AuraX11Details : public PlatformEventDispatcher {
  public:
   AuraX11Details();
-  virtual ~AuraX11Details();
+  ~AuraX11Details() override;
 
   X11AtomCache* atom_cache() { return &atom_cache_; }
 
@@ -290,8 +290,8 @@ class ClipboardAuraX11::AuraX11Details : public PlatformEventDispatcher {
 
  private:
   // PlatformEventDispatcher:
-  virtual bool CanDispatchEvent(const PlatformEvent& event) override;
-  virtual uint32_t DispatchEvent(const PlatformEvent& event) override;
+  bool CanDispatchEvent(const PlatformEvent& event) override;
+  uint32_t DispatchEvent(const PlatformEvent& event) override;
 
   // Our X11 state.
   Display* x_display_;
diff --git a/ui/base/clipboard/clipboard_unittest.cc b/ui/base/clipboard/clipboard_unittest.cc
index 1e05bda..fc34ff5 100644
--- a/ui/base/clipboard/clipboard_unittest.cc
+++ b/ui/base/clipboard/clipboard_unittest.cc
@@ -50,7 +50,7 @@ class ClipboardTest : public PlatformTest {
   ClipboardTest() {}
 #endif
 
-  virtual ~ClipboardTest() {
+  ~ClipboardTest() override {
     ui::Clipboard::DestroyClipboardForCurrentThread();
   }
 
diff --git a/ui/base/cursor/cursor_loader_x11.h b/ui/base/cursor/cursor_loader_x11.h
index 2667221..8c947d1 100644
--- a/ui/base/cursor/cursor_loader_x11.h
+++ b/ui/base/cursor/cursor_loader_x11.h
@@ -20,18 +20,16 @@ namespace ui {
 class UI_BASE_EXPORT CursorLoaderX11 : public CursorLoader {
  public:
   CursorLoaderX11();
-  virtual ~CursorLoaderX11();
+  ~CursorLoaderX11() override;
 
   // Overridden from CursorLoader:
-  virtual void LoadImageCursor(int id,
-                               int resource_id,
-                               const gfx::Point& hot) override;
-  virtual void LoadAnimatedCursor(int id,
-                                  int resource_id,
-                                  const gfx::Point& hot,
-                                  int frame_delay_ms) override;
-  virtual void UnloadAll() override;
-  virtual void SetPlatformCursor(gfx::NativeCursor* cursor) override;
+  void LoadImageCursor(int id, int resource_id, const gfx::Point& hot) override;
+  void LoadAnimatedCursor(int id,
+                          int resource_id,
+                          const gfx::Point& hot,
+                          int frame_delay_ms) override;
+  void UnloadAll() override;
+  void SetPlatformCursor(gfx::NativeCursor* cursor) override;
 
   const XcursorImage* GetXcursorImageForTest(int id);
 
diff --git a/ui/base/dragdrop/drag_utils.cc b/ui/base/dragdrop/drag_utils.cc
index 363dad4..e8723c8 100644
--- a/ui/base/dragdrop/drag_utils.cc
+++ b/ui/base/dragdrop/drag_utils.cc
@@ -36,11 +36,10 @@ class FileDragImageSource : public gfx::CanvasImageSource {
         icon_(icon) {
   }
 
-  virtual ~FileDragImageSource() {
-  }
+  ~FileDragImageSource() override {}
 
   // Overridden from gfx::CanvasImageSource.
-  virtual void Draw(gfx::Canvas* canvas) override {
+  void Draw(gfx::Canvas* canvas) override {
     if (!icon_.isNull()) {
       // Paint the icon.
       canvas->DrawImageInt(icon_, (size().width() - icon_.width()) / 2, 0);
diff --git a/ui/base/dragdrop/os_exchange_data_provider_aurax11.h b/ui/base/dragdrop/os_exchange_data_provider_aurax11.h
index 9664b02..08c93e0 100644
--- a/ui/base/dragdrop/os_exchange_data_provider_aurax11.h
+++ b/ui/base/dragdrop/os_exchange_data_provider_aurax11.h
@@ -43,7 +43,7 @@ class UI_BASE_EXPORT OSExchangeDataProviderAuraX11
   // hidden X11 window to own send data.
   OSExchangeDataProviderAuraX11();
 
-  virtual ~OSExchangeDataProviderAuraX11();
+  ~OSExchangeDataProviderAuraX11() override;
 
   // After all the Set* methods have built up the data we're offering, call
   // this to take ownership of the XdndSelection clipboard.
@@ -61,45 +61,43 @@ class UI_BASE_EXPORT OSExchangeDataProviderAuraX11
   }
 
   // Overridden from OSExchangeData::Provider:
-  virtual Provider* Clone() const override;
-  virtual void MarkOriginatedFromRenderer() override;
-  virtual bool DidOriginateFromRenderer() const override;
-  virtual void SetString(const base::string16& data) override;
-  virtual void SetURL(const GURL& url, const base::string16& title) override;
-  virtual void SetFilename(const base::FilePath& path) override;
-  virtual void SetFilenames(const std::vector<FileInfo>& filenames) override;
-  virtual void SetPickledData(const OSExchangeData::CustomFormat& format,
-                              const Pickle& pickle) override;
-  virtual bool GetString(base::string16* data) const override;
-  virtual bool GetURLAndTitle(OSExchangeData::FilenameToURLPolicy policy,
-                              GURL* url,
-                              base::string16* title) const override;
-  virtual bool GetFilename(base::FilePath* path) const override;
-  virtual bool GetFilenames(std::vector<FileInfo>* filenames) const override;
-  virtual bool GetPickledData(const OSExchangeData::CustomFormat& format,
-                              Pickle* pickle) const override;
-  virtual bool HasString() const override;
-  virtual bool HasURL(OSExchangeData::FilenameToURLPolicy policy) const
-      override;
-  virtual bool HasFile() const override;
-  virtual bool HasCustomFormat(const OSExchangeData::CustomFormat& format) const
-      override;
-
-  virtual void SetFileContents(const base::FilePath& filename,
-                               const std::string& file_contents) override;
-
-  virtual void SetHtml(const base::string16& html,
-                       const GURL& base_url) override;
-  virtual bool GetHtml(base::string16* html, GURL* base_url) const override;
-  virtual bool HasHtml() const override;
-  virtual void SetDragImage(const gfx::ImageSkia& image,
-                            const gfx::Vector2d& cursor_offset) override;
-  virtual const gfx::ImageSkia& GetDragImage() const override;
-  virtual const gfx::Vector2d& GetDragImageOffset() const override;
+  Provider* Clone() const override;
+  void MarkOriginatedFromRenderer() override;
+  bool DidOriginateFromRenderer() const override;
+  void SetString(const base::string16& data) override;
+  void SetURL(const GURL& url, const base::string16& title) override;
+  void SetFilename(const base::FilePath& path) override;
+  void SetFilenames(const std::vector<FileInfo>& filenames) override;
+  void SetPickledData(const OSExchangeData::CustomFormat& format,
+                      const Pickle& pickle) override;
+  bool GetString(base::string16* data) const override;
+  bool GetURLAndTitle(OSExchangeData::FilenameToURLPolicy policy,
+                      GURL* url,
+                      base::string16* title) const override;
+  bool GetFilename(base::FilePath* path) const override;
+  bool GetFilenames(std::vector<FileInfo>* filenames) const override;
+  bool GetPickledData(const OSExchangeData::CustomFormat& format,
+                      Pickle* pickle) const override;
+  bool HasString() const override;
+  bool HasURL(OSExchangeData::FilenameToURLPolicy policy) const override;
+  bool HasFile() const override;
+  bool HasCustomFormat(
+      const OSExchangeData::CustomFormat& format) const override;
+
+  void SetFileContents(const base::FilePath& filename,
+                       const std::string& file_contents) override;
+
+  void SetHtml(const base::string16& html, const GURL& base_url) override;
+  bool GetHtml(base::string16* html, GURL* base_url) const override;
+  bool HasHtml() const override;
+  void SetDragImage(const gfx::ImageSkia& image,
+                    const gfx::Vector2d& cursor_offset) override;
+  const gfx::ImageSkia& GetDragImage() const override;
+  const gfx::Vector2d& GetDragImageOffset() const override;
 
   // ui::PlatformEventDispatcher:
-  virtual bool CanDispatchEvent(const PlatformEvent& event) override;
-  virtual uint32_t DispatchEvent(const PlatformEvent& event) override;
+  bool CanDispatchEvent(const PlatformEvent& event) override;
+  uint32_t DispatchEvent(const PlatformEvent& event) override;
 
  private:
   friend class OSExchangeDataProviderAuraX11Test;
diff --git a/ui/base/ime/input_method_auralinux.h b/ui/base/ime/input_method_auralinux.h
index 505abbd..be8851a 100644
--- a/ui/base/ime/input_method_auralinux.h
+++ b/ui/base/ime/input_method_auralinux.h
@@ -19,32 +19,31 @@ class UI_BASE_EXPORT InputMethodAuraLinux
       public LinuxInputMethodContextDelegate {
  public:
   explicit InputMethodAuraLinux(internal::InputMethodDelegate* delegate);
-  virtual ~InputMethodAuraLinux();
+  ~InputMethodAuraLinux() override;
 
   // Overriden from InputMethod.
-  virtual void Init(bool focused) override;
-  virtual bool OnUntranslatedIMEMessage(const base::NativeEvent& event,
-                                        NativeEventResult* result) override;
-  virtual bool DispatchKeyEvent(const ui::KeyEvent& event) override;
-  virtual void OnTextInputTypeChanged(const TextInputClient* client) override;
-  virtual void OnCaretBoundsChanged(const TextInputClient* client) override;
-  virtual void CancelComposition(const TextInputClient* client) override;
-  virtual void OnInputLocaleChanged() override;
-  virtual std::string GetInputLocale() override;
-  virtual bool IsActive() override;
-  virtual bool IsCandidatePopupOpen() const override;
+  void Init(bool focused) override;
+  bool OnUntranslatedIMEMessage(const base::NativeEvent& event,
+                                NativeEventResult* result) override;
+  bool DispatchKeyEvent(const ui::KeyEvent& event) override;
+  void OnTextInputTypeChanged(const TextInputClient* client) override;
+  void OnCaretBoundsChanged(const TextInputClient* client) override;
+  void CancelComposition(const TextInputClient* client) override;
+  void OnInputLocaleChanged() override;
+  std::string GetInputLocale() override;
+  bool IsActive() override;
+  bool IsCandidatePopupOpen() const override;
 
   // Overriden from ui::LinuxInputMethodContextDelegate
-  virtual void OnCommit(const base::string16& text) override;
-  virtual void OnPreeditChanged(const CompositionText& composition_text)
-      override;
-  virtual void OnPreeditEnd() override;
-  virtual void OnPreeditStart() override;
+  void OnCommit(const base::string16& text) override;
+  void OnPreeditChanged(const CompositionText& composition_text) override;
+  void OnPreeditEnd() override;
+  void OnPreeditStart() override;
 
  protected:
   // Overridden from InputMethodBase.
-  virtual void OnDidChangeFocusedClient(TextInputClient* focused_before,
-                                        TextInputClient* focused) override;
+  void OnDidChangeFocusedClient(TextInputClient* focused_before,
+                                TextInputClient* focused) override;
 
  private:
   // Allows to fire a VKEY_PROCESSKEY key event.
diff --git a/ui/base/ime/input_method_base_unittest.cc b/ui/base/ime/input_method_base_unittest.cc
index 48d0c09..129d3c5 100644
--- a/ui/base/ime/input_method_base_unittest.cc
+++ b/ui/base/ime/input_method_base_unittest.cc
@@ -126,16 +126,11 @@ class InputMethodBaseTest : public testing::Test {
  protected:
   InputMethodBaseTest() {
   }
-  virtual ~InputMethodBaseTest() {
-  }
+  ~InputMethodBaseTest() override {}
 
-  virtual void SetUp() {
-    message_loop_.reset(new base::MessageLoopForUI);
-  }
+  void SetUp() override { message_loop_.reset(new base::MessageLoopForUI); }
 
-  virtual void TearDown() {
-    message_loop_.reset();
-  }
+  void TearDown() override { message_loop_.reset(); }
 
  private:
   scoped_ptr<base::MessageLoop> message_loop_;
diff --git a/ui/base/ime/input_method_minimal.h b/ui/base/ime/input_method_minimal.h
index 14700f5..b797eb8 100644
--- a/ui/base/ime/input_method_minimal.h
+++ b/ui/base/ime/input_method_minimal.h
@@ -14,18 +14,18 @@ namespace ui {
 class UI_BASE_EXPORT InputMethodMinimal : public InputMethodBase {
  public:
   explicit InputMethodMinimal(internal::InputMethodDelegate* delegate);
-  virtual ~InputMethodMinimal();
+  ~InputMethodMinimal() override;
 
   // Overriden from InputMethod.
-  virtual bool OnUntranslatedIMEMessage(const base::NativeEvent& event,
-                                        NativeEventResult* result) override;
-  virtual bool DispatchKeyEvent(const ui::KeyEvent& event) override;
-  virtual void OnCaretBoundsChanged(const TextInputClient* client) override;
-  virtual void CancelComposition(const TextInputClient* client) override;
-  virtual void OnInputLocaleChanged() override;
-  virtual std::string GetInputLocale() override;
-  virtual bool IsActive() override;
-  virtual bool IsCandidatePopupOpen() const override;
+  bool OnUntranslatedIMEMessage(const base::NativeEvent& event,
+                                NativeEventResult* result) override;
+  bool DispatchKeyEvent(const ui::KeyEvent& event) override;
+  void OnCaretBoundsChanged(const TextInputClient* client) override;
+  void CancelComposition(const TextInputClient* client) override;
+  void OnInputLocaleChanged() override;
+  std::string GetInputLocale() override;
+  bool IsActive() override;
+  bool IsCandidatePopupOpen() const override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(InputMethodMinimal);
diff --git a/ui/base/ime/linux/fake_input_method_context.h b/ui/base/ime/linux/fake_input_method_context.h
index d13d2b9..769847e 100644
--- a/ui/base/ime/linux/fake_input_method_context.h
+++ b/ui/base/ime/linux/fake_input_method_context.h
@@ -15,11 +15,10 @@ class FakeInputMethodContext : public LinuxInputMethodContext {
   FakeInputMethodContext();
 
   // Overriden from ui::LinuxInputMethodContext
-  virtual bool DispatchKeyEvent(const ui::KeyEvent& key_event) override;
-  virtual void Reset() override;
-  virtual void OnTextInputTypeChanged(ui::TextInputType text_input_type)
-      override;
-  virtual void OnCaretBoundsChanged(const gfx::Rect& caret_bounds) override;
+  bool DispatchKeyEvent(const ui::KeyEvent& key_event) override;
+  void Reset() override;
+  void OnTextInputTypeChanged(ui::TextInputType text_input_type) override;
+  void OnCaretBoundsChanged(const gfx::Rect& caret_bounds) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FakeInputMethodContext);
diff --git a/ui/base/ime/linux/fake_input_method_context_factory.h b/ui/base/ime/linux/fake_input_method_context_factory.h
index d6101fa..f3d7989 100644
--- a/ui/base/ime/linux/fake_input_method_context_factory.h
+++ b/ui/base/ime/linux/fake_input_method_context_factory.h
@@ -16,7 +16,7 @@ class FakeInputMethodContextFactory : public LinuxInputMethodContextFactory {
   FakeInputMethodContextFactory();
 
   // Overriden from ui::LinuxInputMethodContextFactory
-  virtual scoped_ptr<LinuxInputMethodContext> CreateInputMethodContext(
+  scoped_ptr<LinuxInputMethodContext> CreateInputMethodContext(
       LinuxInputMethodContextDelegate* delegate) const override;
 
  private:
diff --git a/ui/base/models/tree_node_model_unittest.cc b/ui/base/models/tree_node_model_unittest.cc
index ba923aa..f83569f 100644
--- a/ui/base/models/tree_node_model_unittest.cc
+++ b/ui/base/models/tree_node_model_unittest.cc
@@ -22,7 +22,7 @@ class TreeNodeModelTest : public testing::Test, public TreeModelObserver {
       : added_count_(0),
         removed_count_(0),
         changed_count_(0) {}
-  virtual ~TreeNodeModelTest() {}
+  ~TreeNodeModelTest() override {}
 
  protected:
   std::string GetObserverCountStateAndClear() {
diff --git a/ui/base/resource/resource_bundle_unittest.cc b/ui/base/resource/resource_bundle_unittest.cc
index 565bf59..80a92f3 100644
--- a/ui/base/resource/resource_bundle_unittest.cc
+++ b/ui/base/resource/resource_bundle_unittest.cc
@@ -149,13 +149,10 @@ class ResourceBundleTest : public testing::Test {
   ResourceBundleTest() : resource_bundle_(NULL) {
   }
 
-  virtual ~ResourceBundleTest() {
-  }
+  ~ResourceBundleTest() override {}
 
   // Overridden from testing::Test:
-  virtual void TearDown() override {
-    delete resource_bundle_;
-  }
+  void TearDown() override { delete resource_bundle_; }
 
   // Returns new ResoureBundle with the specified |delegate|. The
   // ResourceBundleTest class manages the lifetime of the returned
@@ -380,10 +377,9 @@ class ResourceBundleImageTest : public ResourceBundleTest {
  public:
   ResourceBundleImageTest() {}
 
-  virtual ~ResourceBundleImageTest() {
-  }
+  ~ResourceBundleImageTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     // Create a temporary directory to write test resource bundles to.
     ASSERT_TRUE(dir_.CreateUniqueTempDir());
   }
diff --git a/ui/base/x/selection_requestor_unittest.cc b/ui/base/x/selection_requestor_unittest.cc
index f2c7b03..4095d44 100644
--- a/ui/base/x/selection_requestor_unittest.cc
+++ b/ui/base/x/selection_requestor_unittest.cc
@@ -36,8 +36,7 @@ class SelectionRequestorTest : public testing::Test {
     atom_cache_.allow_uncached_atoms();
   }
 
-  virtual ~SelectionRequestorTest() {
-  }
+  ~SelectionRequestorTest() override {}
 
   // Responds to the SelectionRequestor's XConvertSelection() request by
   // - Setting the property passed into the XConvertSelection() request to
@@ -65,7 +64,7 @@ class SelectionRequestorTest : public testing::Test {
   }
 
  protected:
-  virtual void SetUp() override {
+  void SetUp() override {
     // Make X11 synchronous for our display connection.
     XSynchronize(x_display_, True);
 
@@ -85,7 +84,7 @@ class SelectionRequestorTest : public testing::Test {
     requestor_.reset(new SelectionRequestor(x_display_, x_window_, NULL));
   }
 
-  virtual void TearDown() override {
+  void TearDown() override {
     requestor_.reset();
     event_source_.reset();
     XDestroyWindow(x_display_, x_window_);
diff --git a/ui/base/x/x11_util.h b/ui/base/x/x11_util.h
index cb468a8..ffcf846 100644
--- a/ui/base/x/x11_util.h
+++ b/ui/base/x/x11_util.h
@@ -305,11 +305,11 @@ class UI_BASE_EXPORT XRefcountedMemory : public base::RefCountedMemory {
       : x11_data_(length ? x11_data : NULL), length_(length) {}
 
   // Overridden from RefCountedMemory:
-  virtual const unsigned char* front() const override;
-  virtual size_t size() const override;
+  const unsigned char* front() const override;
+  size_t size() const override;
 
  private:
-  virtual ~XRefcountedMemory();
+  ~XRefcountedMemory() override;
 
   unsigned char* x11_data_;
   size_t length_;
diff --git a/ui/compositor/layer_animator_unittest.cc b/ui/compositor/layer_animator_unittest.cc
index ad4ff61..99d2426 100644
--- a/ui/compositor/layer_animator_unittest.cc
+++ b/ui/compositor/layer_animator_unittest.cc
@@ -80,11 +80,11 @@ class TestImplicitAnimationObserver : public ImplicitAnimationObserver {
 
  private:
   // ImplicitAnimationObserver implementation
-  virtual void OnImplicitAnimationsCompleted() override {
+  void OnImplicitAnimationsCompleted() override {
     animations_completed_ = true;
   }
 
-  virtual bool RequiresNotificationWhenAnimatorDestroyed() const override {
+  bool RequiresNotificationWhenAnimatorDestroyed() const override {
     return notify_when_animator_destructed_;
   }
 
@@ -101,19 +101,15 @@ class DeletingLayerAnimationObserver : public LayerAnimationObserver {
     : animator_(animator) {
   }
 
-  virtual void OnLayerAnimationEnded(
-      LayerAnimationSequence* sequence) override {
+  void OnLayerAnimationEnded(LayerAnimationSequence* sequence) override {
     animator_->StopAnimating();
   }
 
-  virtual void OnLayerAnimationAborted(
-      LayerAnimationSequence* sequence) override {
+  void OnLayerAnimationAborted(LayerAnimationSequence* sequence) override {
     animator_->StopAnimating();
   }
 
-  virtual void OnLayerAnimationScheduled(
-      LayerAnimationSequence* sequence) override {
-  }
+  void OnLayerAnimationScheduled(LayerAnimationSequence* sequence) override {}
 
  private:
   LayerAnimator* animator_;
@@ -151,14 +147,14 @@ class TestLayerAnimator : public LayerAnimator {
   }
 
  protected:
-  virtual ~TestLayerAnimator() {
+  ~TestLayerAnimator() override {
     if (destruction_observer_) {
       destruction_observer_->NotifyAnimatorDeleted();
     }
   }
 
-  virtual void ProgressAnimation(LayerAnimationSequence* sequence,
-                                 base::TimeTicks now) override {
+  void ProgressAnimation(LayerAnimationSequence* sequence,
+                         base::TimeTicks now) override {
     EXPECT_TRUE(HasAnimation(sequence));
     LayerAnimator::ProgressAnimation(sequence, now);
   }
@@ -180,9 +176,7 @@ class TestLayerAnimationSequence : public LayerAnimationSequence {
     (*num_live_instances_)++;
   }
 
-  virtual ~TestLayerAnimationSequence() {
-    (*num_live_instances_)--;
-  }
+  ~TestLayerAnimationSequence() override { (*num_live_instances_)--; }
 
  private:
   int* num_live_instances_;
@@ -1948,7 +1942,7 @@ TEST(LayerAnimatorTest, CallbackDeletesAnimationInProgress) {
         max_width_(max_width) {
     }
 
-    virtual void SetBoundsFromAnimation(const gfx::Rect& bounds) override {
+    void SetBoundsFromAnimation(const gfx::Rect& bounds) override {
       TestLayerAnimationDelegate::SetBoundsFromAnimation(bounds);
       if (bounds.width() > max_width_)
         animator_->StopAnimating();
@@ -2252,7 +2246,7 @@ public:
     animator()->AddObserver(this);
   }
 
-  virtual ~DeletingObserver() {
+  ~DeletingObserver() override {
     animator()->RemoveObserver(this);
     *was_deleted_ = true;
   }
@@ -2281,20 +2275,17 @@ public:
   }
 
   // LayerAnimationObserver implementation.
-  virtual void OnLayerAnimationEnded(
-      LayerAnimationSequence* sequence) override {
+  void OnLayerAnimationEnded(LayerAnimationSequence* sequence) override {
     if (delete_on_animation_ended_)
       delete this;
   }
 
-  virtual void OnLayerAnimationAborted(
-      LayerAnimationSequence* sequence) override {
+  void OnLayerAnimationAborted(LayerAnimationSequence* sequence) override {
     if (delete_on_animation_aborted_)
       delete this;
   }
 
-  virtual void OnLayerAnimationScheduled(
-      LayerAnimationSequence* sequence) override {
+  void OnLayerAnimationScheduled(LayerAnimationSequence* sequence) override {
     if (delete_on_animation_scheduled_)
       delete this;
   }
@@ -2505,10 +2496,10 @@ TEST(LayerAnimatorTest, TestScopedCounterAnimation) {
 class CollectionLayerAnimationDelegate : public TestLayerAnimationDelegate {
  public:
   CollectionLayerAnimationDelegate() : collection(NULL) {}
-  virtual ~CollectionLayerAnimationDelegate() {}
+  ~CollectionLayerAnimationDelegate() override {}
 
   // LayerAnimationDelegate:
-  virtual LayerAnimatorCollection* GetLayerAnimatorCollection() override {
+  LayerAnimatorCollection* GetLayerAnimatorCollection() override {
     return &collection;
   }
 
diff --git a/ui/compositor/layer_unittest.cc b/ui/compositor/layer_unittest.cc
index 6ebe72b..57e1e02 100644
--- a/ui/compositor/layer_unittest.cc
+++ b/ui/compositor/layer_unittest.cc
@@ -59,20 +59,16 @@ class ColoredLayer : public Layer, public LayerDelegate {
     set_delegate(this);
   }
 
-  virtual ~ColoredLayer() { }
+  ~ColoredLayer() override {}
 
   // Overridden from LayerDelegate:
-  virtual void OnPaintLayer(gfx::Canvas* canvas) override {
-    canvas->DrawColor(color_);
-  }
+  void OnPaintLayer(gfx::Canvas* canvas) override { canvas->DrawColor(color_); }
 
-  virtual void OnDelegatedFrameDamage(
-      const gfx::Rect& damage_rect_in_dip) override {}
+  void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
 
-  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) override {
-  }
+  void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
 
-  virtual base::Closure PrepareForLayerBoundsChange() override {
+  base::Closure PrepareForLayerBoundsChange() override {
     return base::Closure();
   }
 
@@ -89,10 +85,10 @@ class LayerWithRealCompositorTest : public testing::Test {
       LOG(ERROR) << "Could not open test data directory.";
     }
   }
-  virtual ~LayerWithRealCompositorTest() {}
+  ~LayerWithRealCompositorTest() override {}
 
   // Overridden from testing::Test:
-  virtual void SetUp() override {
+  void SetUp() override {
     bool enable_pixel_output = true;
     ui::ContextFactory* context_factory =
         InitializeContextFactoryForTests(enable_pixel_output);
@@ -103,7 +99,7 @@ class LayerWithRealCompositorTest : public testing::Test {
     compositor_host_->Show();
   }
 
-  virtual void TearDown() override {
+  void TearDown() override {
     compositor_host_.reset();
     TerminateContextFactoryForTests();
   }
@@ -210,7 +206,7 @@ class LayerWithRealCompositorTest : public testing::Test {
 class TestLayerDelegate : public LayerDelegate {
  public:
   explicit TestLayerDelegate() { reset(); }
-  virtual ~TestLayerDelegate() {}
+  ~TestLayerDelegate() override {}
 
   void AddColor(SkColor color) {
     colors_.push_back(color);
@@ -228,7 +224,7 @@ class TestLayerDelegate : public LayerDelegate {
   }
 
   // Overridden from LayerDelegate:
-  virtual void OnPaintLayer(gfx::Canvas* canvas) override {
+  void OnPaintLayer(gfx::Canvas* canvas) override {
     SkISize size = canvas->sk_canvas()->getBaseLayerSize();
     paint_size_ = gfx::Size(size.width(), size.height());
     canvas->DrawColor(colors_[color_index_]);
@@ -238,14 +234,13 @@ class TestLayerDelegate : public LayerDelegate {
     scale_y_ = matrix.getScaleY();
   }
 
-  virtual void OnDelegatedFrameDamage(
-      const gfx::Rect& damage_rect_in_dip) override {}
+  void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
 
-  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) override {
+  void OnDeviceScaleFactorChanged(float device_scale_factor) override {
     device_scale_factor_ = device_scale_factor;
   }
 
-  virtual base::Closure PrepareForLayerBoundsChange() override {
+  base::Closure PrepareForLayerBoundsChange() override {
     return base::Closure();
   }
 
@@ -271,7 +266,7 @@ class TestLayerDelegate : public LayerDelegate {
 class DrawTreeLayerDelegate : public LayerDelegate {
  public:
   DrawTreeLayerDelegate() : painted_(false) {}
-  virtual ~DrawTreeLayerDelegate() {}
+  ~DrawTreeLayerDelegate() override {}
 
   void Reset() {
     painted_ = false;
@@ -281,15 +276,13 @@ class DrawTreeLayerDelegate : public LayerDelegate {
 
  private:
   // Overridden from LayerDelegate:
-  virtual void OnPaintLayer(gfx::Canvas* canvas) override {
+  void OnPaintLayer(gfx::Canvas* canvas) override {
     painted_ = true;
     canvas->DrawColor(SK_ColorWHITE);
   }
-  virtual void OnDelegatedFrameDamage(
-      const gfx::Rect& damage_rect_in_dip) override {}
-  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) override {
-  }
-  virtual base::Closure PrepareForLayerBoundsChange() override {
+  void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
+  void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
+  base::Closure PrepareForLayerBoundsChange() override {
     return base::Closure();
   }
 
@@ -302,15 +295,14 @@ class DrawTreeLayerDelegate : public LayerDelegate {
 class NullLayerDelegate : public LayerDelegate {
  public:
   NullLayerDelegate() {}
-  virtual ~NullLayerDelegate() {}
+  ~NullLayerDelegate() override {}
 
  private:
   // Overridden from LayerDelegate:
-  virtual void OnPaintLayer(gfx::Canvas* canvas) override {}
-  virtual void OnDelegatedFrameDamage(
-      const gfx::Rect& damage_rect_in_dip) override {}
-  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
-  virtual base::Closure PrepareForLayerBoundsChange() override {
+  void OnPaintLayer(gfx::Canvas* canvas) override {}
+  void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
+  void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
+  base::Closure PrepareForLayerBoundsChange() override {
     return base::Closure();
   }
 
@@ -335,25 +327,22 @@ class TestCompositorObserver : public CompositorObserver {
   }
 
  private:
-  virtual void OnCompositingDidCommit(Compositor* compositor) override {
+  void OnCompositingDidCommit(Compositor* compositor) override {
     committed_ = true;
   }
 
-  virtual void OnCompositingStarted(Compositor* compositor,
-                                    base::TimeTicks start_time) override {
+  void OnCompositingStarted(Compositor* compositor,
+                            base::TimeTicks start_time) override {
     started_ = true;
   }
 
-  virtual void OnCompositingEnded(Compositor* compositor) override {
-    ended_ = true;
-  }
+  void OnCompositingEnded(Compositor* compositor) override { ended_ = true; }
 
-  virtual void OnCompositingAborted(Compositor* compositor) override {
+  void OnCompositingAborted(Compositor* compositor) override {
     aborted_ = true;
   }
 
-  virtual void OnCompositingLockStateChanged(Compositor* compositor) override {
-  }
+  void OnCompositingLockStateChanged(Compositor* compositor) override {}
 
   bool committed_;
   bool started_;
@@ -397,10 +386,10 @@ TEST_F(LayerWithRealCompositorTest, Hierarchy) {
 class LayerWithDelegateTest : public testing::Test {
  public:
   LayerWithDelegateTest() {}
-  virtual ~LayerWithDelegateTest() {}
+  ~LayerWithDelegateTest() override {}
 
   // Overridden from testing::Test:
-  virtual void SetUp() override {
+  void SetUp() override {
     bool enable_pixel_output = false;
     ui::ContextFactory* context_factory =
         InitializeContextFactoryForTests(enable_pixel_output);
@@ -411,7 +400,7 @@ class LayerWithDelegateTest : public testing::Test {
     compositor_host_->Show();
   }
 
-  virtual void TearDown() override {
+  void TearDown() override {
     compositor_host_.reset();
     TerminateContextFactoryForTests();
   }
@@ -606,14 +595,14 @@ TEST_F(LayerWithRealCompositorTest, HierarchyNoTexture) {
 class LayerWithNullDelegateTest : public LayerWithDelegateTest {
  public:
   LayerWithNullDelegateTest() {}
-  virtual ~LayerWithNullDelegateTest() {}
+  ~LayerWithNullDelegateTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     LayerWithDelegateTest::SetUp();
     default_layer_delegate_.reset(new NullLayerDelegate());
   }
 
-  virtual Layer* CreateLayer(LayerType type) override {
+  Layer* CreateLayer(LayerType type) override {
     Layer* layer = new Layer(type);
     layer->set_delegate(default_layer_delegate_.get());
     return layer;
@@ -631,7 +620,7 @@ class LayerWithNullDelegateTest : public LayerWithDelegateTest {
     return layer;
   }
 
-  virtual Layer* CreateNoTextureLayer(const gfx::Rect& bounds) override {
+  Layer* CreateNoTextureLayer(const gfx::Rect& bounds) override {
     Layer* layer = CreateLayer(LAYER_NOT_DRAWN);
     layer->SetBounds(bounds);
     return layer;
@@ -1175,7 +1164,7 @@ class SchedulePaintLayerDelegate : public LayerDelegate {
  public:
   SchedulePaintLayerDelegate() : paint_count_(0), layer_(NULL) {}
 
-  virtual ~SchedulePaintLayerDelegate() {}
+  ~SchedulePaintLayerDelegate() override {}
 
   void set_layer(Layer* layer) {
     layer_ = layer;
@@ -1196,7 +1185,7 @@ class SchedulePaintLayerDelegate : public LayerDelegate {
 
  private:
   // Overridden from LayerDelegate:
-  virtual void OnPaintLayer(gfx::Canvas* canvas) override {
+  void OnPaintLayer(gfx::Canvas* canvas) override {
     paint_count_++;
     if (!schedule_paint_rect_.IsEmpty()) {
       layer_->SchedulePaint(schedule_paint_rect_);
@@ -1207,13 +1196,11 @@ class SchedulePaintLayerDelegate : public LayerDelegate {
       last_clip_rect_ = gfx::SkRectToRectF(sk_clip_rect);
   }
 
-  virtual void OnDelegatedFrameDamage(
-      const gfx::Rect& damage_rect_in_dip) override {}
+  void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
 
-  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) override {
-  }
+  void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
 
-  virtual base::Closure PrepareForLayerBoundsChange() override {
+  base::Closure PrepareForLayerBoundsChange() override {
     return base::Closure();
   }
 
@@ -1712,8 +1699,7 @@ class FrameDamageCheckingDelegate : public TestLayerDelegate {
  public:
   FrameDamageCheckingDelegate() : delegated_frame_damage_called_(false) {}
 
-  virtual void OnDelegatedFrameDamage(
-      const gfx::Rect& damage_rect_in_dip) override {
+  void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {
     delegated_frame_damage_called_ = true;
     delegated_frame_damage_rect_ = damage_rect_in_dip;
   }
diff --git a/ui/compositor/test/test_compositor_host_x11.cc b/ui/compositor/test/test_compositor_host_x11.cc
index d881d15..56ff793 100644
--- a/ui/compositor/test/test_compositor_host_x11.cc
+++ b/ui/compositor/test/test_compositor_host_x11.cc
@@ -23,12 +23,12 @@ class TestCompositorHostX11 : public TestCompositorHost {
  public:
   TestCompositorHostX11(const gfx::Rect& bounds,
                         ui::ContextFactory* context_factory);
-  virtual ~TestCompositorHostX11();
+  ~TestCompositorHostX11() override;
 
  private:
   // Overridden from TestCompositorHost:
-  virtual void Show() override;
-  virtual ui::Compositor* GetCompositor() override;
+  void Show() override;
+  ui::Compositor* GetCompositor() override;
 
   void Draw();
 
diff --git a/ui/gfx/font_render_params_linux_unittest.cc b/ui/gfx/font_render_params_linux_unittest.cc
index a9b230f..ed836b1 100644
--- a/ui/gfx/font_render_params_linux_unittest.cc
+++ b/ui/gfx/font_render_params_linux_unittest.cc
@@ -23,19 +23,19 @@ namespace {
 class TestFontDelegate : public LinuxFontDelegate {
  public:
   TestFontDelegate() {}
-  virtual ~TestFontDelegate() {}
+  ~TestFontDelegate() override {}
 
   void set_params(const FontRenderParams& params) { params_ = params; }
 
-  virtual FontRenderParams GetDefaultFontRenderParams() const override {
+  FontRenderParams GetDefaultFontRenderParams() const override {
     return params_;
   }
-  virtual scoped_ptr<ScopedPangoFontDescription>
-      GetDefaultPangoFontDescription() const override {
+  scoped_ptr<ScopedPangoFontDescription> GetDefaultPangoFontDescription()
+      const override {
     NOTIMPLEMENTED();
     return scoped_ptr<ScopedPangoFontDescription>();
   }
-  virtual double GetFontDPI() const override {
+  double GetFontDPI() const override {
     NOTIMPLEMENTED();
     return 96.0;
   }
@@ -70,7 +70,7 @@ class FontRenderParamsTest : public testing::Test {
     ClearFontRenderParamsCacheForTest();
   }
 
-  virtual ~FontRenderParamsTest() {
+  ~FontRenderParamsTest() override {
     LinuxFontDelegate::SetInstance(
         const_cast<LinuxFontDelegate*>(original_font_delegate_));
     TearDownFontconfig();
diff --git a/ui/gfx/image/image_family_unittest.cc b/ui/gfx/image/image_family_unittest.cc
index f9dd401..20167c6 100644
--- a/ui/gfx/image/image_family_unittest.cc
+++ b/ui/gfx/image/image_family_unittest.cc
@@ -26,7 +26,7 @@ do { \
 class ImageFamilyTest : public testing::Test {
  public:
   // Construct an ImageFamily. Implicitly tests Add and Empty.
-  virtual void SetUp() override {
+  void SetUp() override {
     EXPECT_TRUE(image_family_.empty());
 
     // Aspect ratio 1:1.
diff --git a/ui/gfx/image/image_skia_unittest.cc b/ui/gfx/image/image_skia_unittest.cc
index a8bd66d..a5ce86e 100644
--- a/ui/gfx/image/image_skia_unittest.cc
+++ b/ui/gfx/image/image_skia_unittest.cc
@@ -150,9 +150,7 @@ class ImageSkiaTest : public testing::Test {
     supported_scales.push_back(2.0f);
     ImageSkia::SetSupportedScales(supported_scales);
   }
-  virtual ~ImageSkiaTest() {
-    ImageSkia::SetSupportedScales(old_scales_);
-  }
+  ~ImageSkiaTest() override { ImageSkia::SetSupportedScales(old_scales_); }
 
  private:
   std::vector<float> old_scales_;
diff --git a/ui/gfx/platform_font_pango.h b/ui/gfx/platform_font_pango.h
index 5041bbb..e70dd6a 100644
--- a/ui/gfx/platform_font_pango.h
+++ b/ui/gfx/platform_font_pango.h
@@ -41,17 +41,17 @@ class GFX_EXPORT PlatformFontPango : public PlatformFont {
 #endif
 
   // Overridden from PlatformFont:
-  virtual Font DeriveFont(int size_delta, int style) const override;
-  virtual int GetHeight() const override;
-  virtual int GetBaseline() const override;
-  virtual int GetCapHeight() const override;
-  virtual int GetExpectedTextWidth(int length) const override;
-  virtual int GetStyle() const override;
-  virtual std::string GetFontName() const override;
-  virtual std::string GetActualFontNameForTesting() const override;
-  virtual int GetFontSize() const override;
-  virtual const FontRenderParams& GetFontRenderParams() const override;
-  virtual NativeFont GetNativeFont() const override;
+  Font DeriveFont(int size_delta, int style) const override;
+  int GetHeight() const override;
+  int GetBaseline() const override;
+  int GetCapHeight() const override;
+  int GetExpectedTextWidth(int length) const override;
+  int GetStyle() const override;
+  std::string GetFontName() const override;
+  std::string GetActualFontNameForTesting() const override;
+  int GetFontSize() const override;
+  const FontRenderParams& GetFontRenderParams() const override;
+  NativeFont GetNativeFont() const override;
 
  private:
   // Create a new instance of this object with the specified properties. Called
@@ -61,7 +61,7 @@ class GFX_EXPORT PlatformFontPango : public PlatformFont {
                     int size_pixels,
                     int style,
                     const FontRenderParams& params);
-  virtual ~PlatformFontPango();
+  ~PlatformFontPango() override;
 
   // Initializes this object based on the passed-in details. If |typeface| is
   // empty, a new typeface will be loaded.
diff --git a/ui/gfx/render_text_pango.h b/ui/gfx/render_text_pango.h
index 9e4c55c..223dbb6 100644
--- a/ui/gfx/render_text_pango.h
+++ b/ui/gfx/render_text_pango.h
@@ -16,30 +16,30 @@ namespace gfx {
 class RenderTextPango : public RenderText {
  public:
   RenderTextPango();
-  virtual ~RenderTextPango();
+  ~RenderTextPango() override;
 
   // Overridden from RenderText:
-  virtual Size GetStringSize() override;
-  virtual SelectionModel FindCursorPosition(const Point& point) override;
-  virtual std::vector<FontSpan> GetFontSpansForTesting() override;
+  Size GetStringSize() override;
+  SelectionModel FindCursorPosition(const Point& point) override;
+  std::vector<FontSpan> GetFontSpansForTesting() override;
 
  protected:
   // Overridden from RenderText:
-  virtual int GetLayoutTextBaseline() override;
-  virtual SelectionModel AdjacentCharSelectionModel(
+  int GetLayoutTextBaseline() override;
+  SelectionModel AdjacentCharSelectionModel(
       const SelectionModel& selection,
       VisualCursorDirection direction) override;
-  virtual SelectionModel AdjacentWordSelectionModel(
+  SelectionModel AdjacentWordSelectionModel(
       const SelectionModel& selection,
       VisualCursorDirection direction) override;
-  virtual Range GetGlyphBounds(size_t index) override;
-  virtual std::vector<Rect> GetSubstringBounds(const Range& range) override;
-  virtual size_t TextIndexToLayoutIndex(size_t index) const override;
-  virtual size_t LayoutIndexToTextIndex(size_t index) const override;
-  virtual bool IsValidCursorIndex(size_t index) override;
-  virtual void ResetLayout() override;
-  virtual void EnsureLayout() override;
-  virtual void DrawVisualText(Canvas* canvas) override;
+  Range GetGlyphBounds(size_t index) override;
+  std::vector<Rect> GetSubstringBounds(const Range& range) override;
+  size_t TextIndexToLayoutIndex(size_t index) const override;
+  size_t LayoutIndexToTextIndex(size_t index) const override;
+  bool IsValidCursorIndex(size_t index) override;
+  void ResetLayout() override;
+  void EnsureLayout() override;
+  void DrawVisualText(Canvas* canvas) override;
 
  private:
   friend class RenderTextTest;
diff --git a/ui/gl/gl_context_egl.h b/ui/gl/gl_context_egl.h
index 82d15a6..9f071e2 100644
--- a/ui/gl/gl_context_egl.h
+++ b/ui/gl/gl_context_egl.h
@@ -24,21 +24,21 @@ class GLContextEGL : public GLContextReal {
   explicit GLContextEGL(GLShareGroup* share_group);
 
   // Implement GLContext.
-  virtual bool Initialize(
-      GLSurface* compatible_surface, GpuPreference gpu_preference) override;
-  virtual void Destroy() override;
-  virtual bool MakeCurrent(GLSurface* surface) override;
-  virtual void ReleaseCurrent(GLSurface* surface) override;
-  virtual bool IsCurrent(GLSurface* surface) override;
-  virtual void* GetHandle() override;
-  virtual void SetSwapInterval(int interval) override;
-  virtual std::string GetExtensions() override;
-  virtual bool WasAllocatedUsingRobustnessExtension() override;
-  virtual bool GetTotalGpuMemory(size_t* bytes) override;
-  virtual void SetUnbindFboOnMakeCurrent() override;
+  bool Initialize(GLSurface* compatible_surface,
+                  GpuPreference gpu_preference) override;
+  void Destroy() override;
+  bool MakeCurrent(GLSurface* surface) override;
+  void ReleaseCurrent(GLSurface* surface) override;
+  bool IsCurrent(GLSurface* surface) override;
+  void* GetHandle() override;
+  void SetSwapInterval(int interval) override;
+  std::string GetExtensions() override;
+  bool WasAllocatedUsingRobustnessExtension() override;
+  bool GetTotalGpuMemory(size_t* bytes) override;
+  void SetUnbindFboOnMakeCurrent() override;
 
  protected:
-  virtual ~GLContextEGL();
+  ~GLContextEGL() override;
 
  private:
   EGLContext context_;
diff --git a/ui/gl/gl_context_glx.h b/ui/gl/gl_context_glx.h
index ca53403..fe3d754 100644
--- a/ui/gl/gl_context_glx.h
+++ b/ui/gl/gl_context_glx.h
@@ -24,20 +24,20 @@ class GL_EXPORT GLContextGLX : public GLContextReal {
   XDisplay* display();
 
   // Implement GLContext.
-  virtual bool Initialize(
-      GLSurface* compatible_surface, GpuPreference gpu_preference) override;
-  virtual void Destroy() override;
-  virtual bool MakeCurrent(GLSurface* surface) override;
-  virtual void ReleaseCurrent(GLSurface* surface) override;
-  virtual bool IsCurrent(GLSurface* surface) override;
-  virtual void* GetHandle() override;
-  virtual void SetSwapInterval(int interval) override;
-  virtual std::string GetExtensions() override;
-  virtual bool GetTotalGpuMemory(size_t* bytes) override;
-  virtual bool WasAllocatedUsingRobustnessExtension() override;
+  bool Initialize(GLSurface* compatible_surface,
+                  GpuPreference gpu_preference) override;
+  void Destroy() override;
+  bool MakeCurrent(GLSurface* surface) override;
+  void ReleaseCurrent(GLSurface* surface) override;
+  bool IsCurrent(GLSurface* surface) override;
+  void* GetHandle() override;
+  void SetSwapInterval(int interval) override;
+  std::string GetExtensions() override;
+  bool GetTotalGpuMemory(size_t* bytes) override;
+  bool WasAllocatedUsingRobustnessExtension() override;
 
  protected:
-  virtual ~GLContextGLX();
+  ~GLContextGLX() override;
 
  private:
   void* context_;
diff --git a/ui/gl/gl_egl_api_implementation.h b/ui/gl/gl_egl_api_implementation.h
index aef46ee..e58860c 100644
--- a/ui/gl/gl_egl_api_implementation.h
+++ b/ui/gl/gl_egl_api_implementation.h
@@ -29,7 +29,7 @@ class GL_EXPORT EGLApiBase : public EGLApi {
 
  protected:
   EGLApiBase();
-  virtual ~EGLApiBase();
+  ~EGLApiBase() override;
   void InitializeBase(DriverEGL* driver);
 
   DriverEGL* driver_;
@@ -38,7 +38,7 @@ class GL_EXPORT EGLApiBase : public EGLApi {
 class GL_EXPORT RealEGLApi : public EGLApiBase {
  public:
   RealEGLApi();
-  virtual ~RealEGLApi();
+  ~RealEGLApi() override;
   void Initialize(DriverEGL* driver);
 };
 
@@ -47,7 +47,7 @@ class GL_EXPORT RealEGLApi : public EGLApiBase {
 class GL_EXPORT TraceEGLApi : public EGLApi {
  public:
   TraceEGLApi(EGLApi* egl_api) : egl_api_(egl_api) { }
-  virtual ~TraceEGLApi();
+  ~TraceEGLApi() override;
 
   // Include the auto-generated part of this class. We split this because
   // it means we can easily edit the non-auto generated parts right here in
diff --git a/ui/gl/gl_glx_api_implementation.h b/ui/gl/gl_glx_api_implementation.h
index 634db4e..30a70cf 100644
--- a/ui/gl/gl_glx_api_implementation.h
+++ b/ui/gl/gl_glx_api_implementation.h
@@ -29,7 +29,7 @@ class GL_EXPORT GLXApiBase : public GLXApi {
 
  protected:
   GLXApiBase();
-  virtual ~GLXApiBase();
+  ~GLXApiBase() override;
   void InitializeBase(DriverGLX* driver);
 
   DriverGLX* driver_;
@@ -38,7 +38,7 @@ class GL_EXPORT GLXApiBase : public GLXApi {
 class GL_EXPORT RealGLXApi : public GLXApiBase {
  public:
   RealGLXApi();
-  virtual ~RealGLXApi();
+  ~RealGLXApi() override;
   void Initialize(DriverGLX* driver);
 };
 
@@ -46,7 +46,7 @@ class GL_EXPORT RealGLXApi : public GLXApiBase {
 class GL_EXPORT TraceGLXApi : public GLXApi {
  public:
   TraceGLXApi(GLXApi* glx_api) : glx_api_(glx_api) { }
-  virtual ~TraceGLXApi();
+  ~TraceGLXApi() override;
 
   // Include the auto-generated part of this class. We split this because
   // it means we can easily edit the non-auto generated parts right here in
diff --git a/ui/gl/gl_image_egl.h b/ui/gl/gl_image_egl.h
index c1ec1fc..716761f 100644
--- a/ui/gl/gl_image_egl.h
+++ b/ui/gl/gl_image_egl.h
@@ -17,23 +17,23 @@ class GL_EXPORT GLImageEGL : public GLImage {
   bool Initialize(EGLenum target, EGLClientBuffer buffer, const EGLint* attrs);
 
   // Overridden from GLImage:
-  virtual void Destroy(bool have_context) override;
-  virtual gfx::Size GetSize() override;
-  virtual bool BindTexImage(unsigned target) override;
-  virtual void ReleaseTexImage(unsigned target) override {}
-  virtual bool CopyTexImage(unsigned target) override;
-  virtual void WillUseTexImage() override {}
-  virtual void DidUseTexImage() override {}
-  virtual void WillModifyTexImage() override {}
-  virtual void DidModifyTexImage() override {}
-  virtual bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
-                                    int z_order,
-                                    OverlayTransform transform,
-                                    const Rect& bounds_rect,
-                                    const RectF& crop_rect) override;
+  void Destroy(bool have_context) override;
+  gfx::Size GetSize() override;
+  bool BindTexImage(unsigned target) override;
+  void ReleaseTexImage(unsigned target) override {}
+  bool CopyTexImage(unsigned target) override;
+  void WillUseTexImage() override {}
+  void DidUseTexImage() override {}
+  void WillModifyTexImage() override {}
+  void DidModifyTexImage() override {}
+  bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
+                            int z_order,
+                            OverlayTransform transform,
+                            const Rect& bounds_rect,
+                            const RectF& crop_rect) override;
 
  protected:
-  virtual ~GLImageEGL();
+  ~GLImageEGL() override;
 
   EGLImageKHR egl_image_;
   const gfx::Size size_;
diff --git a/ui/gl/gl_image_glx.h b/ui/gl/gl_image_glx.h
index 57c55c56..f6031e2 100644
--- a/ui/gl/gl_image_glx.h
+++ b/ui/gl/gl_image_glx.h
@@ -19,23 +19,23 @@ class GL_EXPORT GLImageGLX : public GLImage {
   bool Initialize(XID pixmap);
 
   // Overridden from GLImage:
-  virtual void Destroy(bool have_context) override;
-  virtual gfx::Size GetSize() override;
-  virtual bool BindTexImage(unsigned target) override;
-  virtual void ReleaseTexImage(unsigned target) override;
-  virtual bool CopyTexImage(unsigned target) override;
-  virtual void WillUseTexImage() override {}
-  virtual void DidUseTexImage() override {}
-  virtual void WillModifyTexImage() override {}
-  virtual void DidModifyTexImage() override {}
-  virtual bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
-                                    int z_order,
-                                    OverlayTransform transform,
-                                    const Rect& bounds_rect,
-                                    const RectF& crop_rect) override;
+  void Destroy(bool have_context) override;
+  gfx::Size GetSize() override;
+  bool BindTexImage(unsigned target) override;
+  void ReleaseTexImage(unsigned target) override;
+  bool CopyTexImage(unsigned target) override;
+  void WillUseTexImage() override {}
+  void DidUseTexImage() override {}
+  void WillModifyTexImage() override {}
+  void DidModifyTexImage() override {}
+  bool ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
+                            int z_order,
+                            OverlayTransform transform,
+                            const Rect& bounds_rect,
+                            const RectF& crop_rect) override;
 
  protected:
-  virtual ~GLImageGLX();
+  ~GLImageGLX() override;
 
  private:
   XID glx_pixmap_;
diff --git a/ui/gl/gl_image_linux_dma_buffer.h b/ui/gl/gl_image_linux_dma_buffer.h
index 3523915..5256211 100644
--- a/ui/gl/gl_image_linux_dma_buffer.h
+++ b/ui/gl/gl_image_linux_dma_buffer.h
@@ -21,7 +21,7 @@ class GL_EXPORT GLImageLinuxDMABuffer : public GLImageEGL {
                   int pitch);
 
  protected:
-  virtual ~GLImageLinuxDMABuffer();
+  ~GLImageLinuxDMABuffer() override;
 
  private:
   unsigned internalformat_;
diff --git a/ui/gl/gl_surface_egl.cc b/ui/gl/gl_surface_egl.cc
index b8c29d7..a977edd 100644
--- a/ui/gl/gl_surface_egl.cc
+++ b/ui/gl/gl_surface_egl.cc
@@ -74,12 +74,12 @@ class EGLSyncControlVSyncProvider
         surface_(surface) {
   }
 
-  virtual ~EGLSyncControlVSyncProvider() { }
+  ~EGLSyncControlVSyncProvider() override {}
 
  protected:
-  virtual bool GetSyncValues(int64* system_time,
-                             int64* media_stream_counter,
-                             int64* swap_buffer_counter) override {
+  bool GetSyncValues(int64* system_time,
+                     int64* media_stream_counter,
+                     int64* swap_buffer_counter) override {
     uint64 u_system_time, u_media_stream_counter, u_swap_buffer_counter;
     bool result = eglGetSyncValuesCHROMIUM(
         g_display, surface_, &u_system_time,
@@ -92,7 +92,7 @@ class EGLSyncControlVSyncProvider
     return result;
   }
 
-  virtual bool GetMscRate(int32* numerator, int32* denominator) override {
+  bool GetMscRate(int32* numerator, int32* denominator) override {
     return false;
   }
 
diff --git a/ui/gl/gl_surface_glx.cc b/ui/gl/gl_surface_glx.cc
index 7189c5a..dd3eed9 100644
--- a/ui/gl/gl_surface_glx.cc
+++ b/ui/gl/gl_surface_glx.cc
@@ -77,17 +77,17 @@ class OMLSyncControlVSyncProvider
         window_(window) {
   }
 
-  virtual ~OMLSyncControlVSyncProvider() { }
+  ~OMLSyncControlVSyncProvider() override {}
 
  protected:
-  virtual bool GetSyncValues(int64* system_time,
-                             int64* media_stream_counter,
-                             int64* swap_buffer_counter) override {
+  bool GetSyncValues(int64* system_time,
+                     int64* media_stream_counter,
+                     int64* swap_buffer_counter) override {
     return glXGetSyncValuesOML(g_display, window_, system_time,
                                media_stream_counter, swap_buffer_counter);
   }
 
-  virtual bool GetMscRate(int32* numerator, int32* denominator) override {
+  bool GetMscRate(int32* numerator, int32* denominator) override {
     if (!g_glx_get_msc_rate_oml_supported)
       return false;
 
@@ -127,7 +127,7 @@ class SGIVideoSyncThread
     DCHECK(CalledOnValidThread());
   }
 
-  virtual ~SGIVideoSyncThread() {
+  ~SGIVideoSyncThread() override {
     DCHECK(CalledOnValidThread());
     g_video_sync_thread = NULL;
     Stop();
@@ -256,7 +256,7 @@ class SGIVideoSyncVSyncProvider
                    base::Unretained(shim_.get())));
   }
 
-  virtual ~SGIVideoSyncVSyncProvider() {
+  ~SGIVideoSyncVSyncProvider() override {
     {
       base::AutoLock locked(*vsync_lock_);
       cancel_vsync_flag_->Set();
@@ -268,7 +268,7 @@ class SGIVideoSyncVSyncProvider
         shim_.release());
   }
 
-  virtual void GetVSyncParameters(
+  void GetVSyncParameters(
       const VSyncProvider::UpdateVSyncCallback& callback) override {
     if (kGetVSyncParametersMinPeriod > base::TimeDelta()) {
       base::TimeTicks now = base::TimeTicks::Now();
diff --git a/ui/gl/gl_surface_glx.h b/ui/gl/gl_surface_glx.h
index 0627023..369def4 100644
--- a/ui/gl/gl_surface_glx.h
+++ b/ui/gl/gl_surface_glx.h
@@ -35,14 +35,14 @@ class GL_EXPORT GLSurfaceGLX : public GLSurface {
   static bool IsTextureFromPixmapSupported();
   static bool IsOMLSyncControlSupported();
 
-  virtual void* GetDisplay() override;
+  void* GetDisplay() override;
 
   // Get the FB config that the surface was created with or NULL if it is not
   // a GLX drawable.
   virtual void* GetConfig() = 0;
 
  protected:
-  virtual ~GLSurfaceGLX();
+  ~GLSurfaceGLX() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(GLSurfaceGLX);
@@ -55,28 +55,28 @@ class GL_EXPORT NativeViewGLSurfaceGLX : public GLSurfaceGLX,
   explicit NativeViewGLSurfaceGLX(gfx::AcceleratedWidget window);
 
   // Implement GLSurfaceGLX.
-  virtual bool Initialize() override;
-  virtual void Destroy() override;
-  virtual bool Resize(const gfx::Size& size) override;
-  virtual bool IsOffscreen() override;
-  virtual bool SwapBuffers() override;
-  virtual gfx::Size GetSize() override;
-  virtual void* GetHandle() override;
-  virtual bool SupportsPostSubBuffer() override;
-  virtual void* GetConfig() override;
-  virtual bool PostSubBuffer(int x, int y, int width, int height) override;
-  virtual VSyncProvider* GetVSyncProvider() override;
+  bool Initialize() override;
+  void Destroy() override;
+  bool Resize(const gfx::Size& size) override;
+  bool IsOffscreen() override;
+  bool SwapBuffers() override;
+  gfx::Size GetSize() override;
+  void* GetHandle() override;
+  bool SupportsPostSubBuffer() override;
+  void* GetConfig() override;
+  bool PostSubBuffer(int x, int y, int width, int height) override;
+  VSyncProvider* GetVSyncProvider() override;
 
  protected:
-  virtual ~NativeViewGLSurfaceGLX();
+  ~NativeViewGLSurfaceGLX() override;
 
  private:
   // The handle for the drawable to make current or swap.
   gfx::AcceleratedWidget GetDrawableHandle() const;
 
   // PlatformEventDispatcher implementation
-  virtual bool CanDispatchEvent(const ui::PlatformEvent& event) override;
-  virtual uint32_t DispatchEvent(const ui::PlatformEvent& event) override;
+  bool CanDispatchEvent(const ui::PlatformEvent& event) override;
+  uint32_t DispatchEvent(const ui::PlatformEvent& event) override;
 
   // Window passed in at creation. Always valid.
   gfx::AcceleratedWidget parent_window_;
@@ -98,16 +98,16 @@ class GL_EXPORT PbufferGLSurfaceGLX : public GLSurfaceGLX {
   explicit PbufferGLSurfaceGLX(const gfx::Size& size);
 
   // Implement GLSurfaceGLX.
-  virtual bool Initialize() override;
-  virtual void Destroy() override;
-  virtual bool IsOffscreen() override;
-  virtual bool SwapBuffers() override;
-  virtual gfx::Size GetSize() override;
-  virtual void* GetHandle() override;
-  virtual void* GetConfig() override;
+  bool Initialize() override;
+  void Destroy() override;
+  bool IsOffscreen() override;
+  bool SwapBuffers() override;
+  gfx::Size GetSize() override;
+  void* GetHandle() override;
+  void* GetConfig() override;
 
  protected:
-  virtual ~PbufferGLSurfaceGLX();
+  ~PbufferGLSurfaceGLX() override;
 
  private:
   gfx::Size size_;
diff --git a/ui/gl/gl_surface_x11.cc b/ui/gl/gl_surface_x11.cc
index 55a0f38..895eb937 100644
--- a/ui/gl/gl_surface_x11.cc
+++ b/ui/gl/gl_surface_x11.cc
@@ -28,16 +28,16 @@ class NativeViewGLSurfaceOSMesa : public GLSurfaceOSMesa {
   static bool InitializeOneOff();
 
   // Implement a subset of GLSurface.
-  virtual bool Initialize() override;
-  virtual void Destroy() override;
-  virtual bool Resize(const gfx::Size& new_size) override;
-  virtual bool IsOffscreen() override;
-  virtual bool SwapBuffers() override;
-  virtual bool SupportsPostSubBuffer() override;
-  virtual bool PostSubBuffer(int x, int y, int width, int height) override;
+  bool Initialize() override;
+  void Destroy() override;
+  bool Resize(const gfx::Size& new_size) override;
+  bool IsOffscreen() override;
+  bool SwapBuffers() override;
+  bool SupportsPostSubBuffer() override;
+  bool PostSubBuffer(int x, int y, int width, int height) override;
 
  protected:
-  virtual ~NativeViewGLSurfaceOSMesa();
+  ~NativeViewGLSurfaceOSMesa() override;
 
  private:
   Display* xdisplay_;
diff --git a/ui/keyboard/keyboard_controller.cc b/ui/keyboard/keyboard_controller.cc
index 396ac49..4fdf8f0 100644
--- a/ui/keyboard/keyboard_controller.cc
+++ b/ui/keyboard/keyboard_controller.cc
@@ -57,12 +57,11 @@ class KeyboardContainerTargeter : public wm::MaskedWindowTargeter {
         proxy_(proxy) {
   }
 
-  virtual ~KeyboardContainerTargeter() {}
+  ~KeyboardContainerTargeter() override {}
 
  private:
   // wm::MaskedWindowTargeter:
-  virtual bool GetHitTestMask(aura::Window* window,
-                              gfx::Path* mask) const override {
+  bool GetHitTestMask(aura::Window* window, gfx::Path* mask) const override {
     if (proxy_ && !proxy_->HasKeyboardWindow())
       return true;
     gfx::Rect keyboard_bounds = proxy_ ? proxy_->GetKeyboardWindow()->bounds() :
@@ -84,38 +83,38 @@ class KeyboardWindowDelegate : public aura::WindowDelegate {
  public:
   explicit KeyboardWindowDelegate(keyboard::KeyboardControllerProxy* proxy)
       : proxy_(proxy) {}
-  virtual ~KeyboardWindowDelegate() {}
+  ~KeyboardWindowDelegate() override {}
 
  private:
   // Overridden from aura::WindowDelegate:
-  virtual gfx::Size GetMinimumSize() const override { return gfx::Size(); }
-  virtual gfx::Size GetMaximumSize() const override { return gfx::Size(); }
-  virtual void OnBoundsChanged(const gfx::Rect& old_bounds,
-                               const gfx::Rect& new_bounds) override {
+  gfx::Size GetMinimumSize() const override { return gfx::Size(); }
+  gfx::Size GetMaximumSize() const override { return gfx::Size(); }
+  void OnBoundsChanged(const gfx::Rect& old_bounds,
+                       const gfx::Rect& new_bounds) override {
     bounds_ = new_bounds;
   }
-  virtual gfx::NativeCursor GetCursor(const gfx::Point& point) override {
+  gfx::NativeCursor GetCursor(const gfx::Point& point) override {
     return gfx::kNullCursor;
   }
-  virtual int GetNonClientComponent(const gfx::Point& point) const override {
+  int GetNonClientComponent(const gfx::Point& point) const override {
     return HTNOWHERE;
   }
-  virtual bool ShouldDescendIntoChildForEventHandling(
+  bool ShouldDescendIntoChildForEventHandling(
       aura::Window* child,
       const gfx::Point& location) override {
     return true;
   }
-  virtual bool CanFocus() override { return false; }
-  virtual void OnCaptureLost() override {}
-  virtual void OnPaint(gfx::Canvas* canvas) override {}
-  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
-  virtual void OnWindowDestroying(aura::Window* window) override {}
-  virtual void OnWindowDestroyed(aura::Window* window) override { delete this; }
-  virtual void OnWindowTargetVisibilityChanged(bool visible) override {}
-  virtual bool HasHitTestMask() const override {
+  bool CanFocus() override { return false; }
+  void OnCaptureLost() override {}
+  void OnPaint(gfx::Canvas* canvas) override {}
+  void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
+  void OnWindowDestroying(aura::Window* window) override {}
+  void OnWindowDestroyed(aura::Window* window) override { delete this; }
+  void OnWindowTargetVisibilityChanged(bool visible) override {}
+  bool HasHitTestMask() const override {
     return !proxy_ || proxy_->HasKeyboardWindow();
   }
-  virtual void GetHitTestMask(gfx::Path* mask) const override {
+  void GetHitTestMask(gfx::Path* mask) const override {
     if (proxy_ && !proxy_->HasKeyboardWindow())
       return;
     gfx::Rect keyboard_bounds = proxy_ ? proxy_->GetKeyboardWindow()->bounds() :
@@ -167,15 +166,13 @@ class CallbackAnimationObserver : public ui::LayerAnimationObserver {
  public:
   CallbackAnimationObserver(ui::LayerAnimator* animator,
                             base::Callback<void(void)> callback);
-  virtual ~CallbackAnimationObserver();
+  ~CallbackAnimationObserver() override;
 
  private:
   // Overridden from ui::LayerAnimationObserver:
-  virtual void OnLayerAnimationEnded(ui::LayerAnimationSequence* seq) override;
-  virtual void OnLayerAnimationAborted(
-      ui::LayerAnimationSequence* seq) override;
-  virtual void OnLayerAnimationScheduled(
-      ui::LayerAnimationSequence* seq) override {}
+  void OnLayerAnimationEnded(ui::LayerAnimationSequence* seq) override;
+  void OnLayerAnimationAborted(ui::LayerAnimationSequence* seq) override;
+  void OnLayerAnimationScheduled(ui::LayerAnimationSequence* seq) override {}
 
   ui::LayerAnimator* animator_;
   base::Callback<void(void)> callback_;
@@ -207,10 +204,10 @@ void CallbackAnimationObserver::OnLayerAnimationAborted(
 
 class WindowBoundsChangeObserver : public aura::WindowObserver {
  public:
-  virtual void OnWindowBoundsChanged(aura::Window* window,
-                                     const gfx::Rect& old_bounds,
-                                     const gfx::Rect& new_bounds) override;
-  virtual void OnWindowDestroyed(aura::Window* window) override;
+  void OnWindowBoundsChanged(aura::Window* window,
+                             const gfx::Rect& old_bounds,
+                             const gfx::Rect& new_bounds) override;
+  void OnWindowDestroyed(aura::Window* window) override;
 
   void AddObservedWindow(aura::Window* window);
   void RemoveAllObservedWindows();
diff --git a/ui/keyboard/keyboard_controller_proxy.cc b/ui/keyboard/keyboard_controller_proxy.cc
index 37f655d..6a28869 100644
--- a/ui/keyboard/keyboard_controller_proxy.cc
+++ b/ui/keyboard/keyboard_controller_proxy.cc
@@ -31,11 +31,11 @@ class KeyboardContentsDelegate : public content::WebContentsDelegate,
  public:
   KeyboardContentsDelegate(keyboard::KeyboardControllerProxy* proxy)
       : proxy_(proxy) {}
-  virtual ~KeyboardContentsDelegate() {}
+  ~KeyboardContentsDelegate() override {}
 
  private:
   // Overridden from content::WebContentsDelegate:
-  virtual content::WebContents* OpenURLFromTab(
+  content::WebContents* OpenURLFromTab(
       content::WebContents* source,
       const content::OpenURLParams& params) override {
     source->GetController().LoadURL(
@@ -44,13 +44,12 @@ class KeyboardContentsDelegate : public content::WebContentsDelegate,
     return source;
   }
 
-  virtual bool IsPopupOrPanel(
-      const content::WebContents* source) const override {
+  bool IsPopupOrPanel(const content::WebContents* source) const override {
     return true;
   }
 
-  virtual void MoveContents(content::WebContents* source,
-                            const gfx::Rect& pos) override {
+  void MoveContents(content::WebContents* source,
+                    const gfx::Rect& pos) override {
     aura::Window* keyboard = proxy_->GetKeyboardWindow();
     // keyboard window must have been added to keyboard container window at this
     // point. Otherwise, wrong keyboard bounds is used and may cause problem as
@@ -68,16 +67,15 @@ class KeyboardContentsDelegate : public content::WebContentsDelegate,
   }
 
   // Overridden from content::WebContentsDelegate:
-  virtual void RequestMediaAccessPermission(content::WebContents* web_contents,
+  void RequestMediaAccessPermission(
+      content::WebContents* web_contents,
       const content::MediaStreamRequest& request,
       const content::MediaResponseCallback& callback) override {
     proxy_->RequestAudioInput(web_contents, request, callback);
   }
 
   // Overridden from content::WebContentsObserver:
-  virtual void WebContentsDestroyed() override {
-    delete this;
-  }
+  void WebContentsDestroyed() override { delete this; }
 
   keyboard::KeyboardControllerProxy* proxy_;
 
diff --git a/ui/keyboard/keyboard_controller_proxy.h b/ui/keyboard/keyboard_controller_proxy.h
index f893eea..86d95b4 100644
--- a/ui/keyboard/keyboard_controller_proxy.h
+++ b/ui/keyboard/keyboard_controller_proxy.h
@@ -50,7 +50,7 @@ class KEYBOARD_EXPORT KeyboardControllerProxy : public aura::WindowObserver {
   };
 
   KeyboardControllerProxy();
-  virtual ~KeyboardControllerProxy();
+  ~KeyboardControllerProxy() override;
 
   // Gets the virtual keyboard window.  Ownership of the returned Window remains
   // with the proxy.
@@ -113,10 +113,10 @@ class KEYBOARD_EXPORT KeyboardControllerProxy : public aura::WindowObserver {
   virtual void SetupWebContents(content::WebContents* contents);
 
   // aura::WindowObserver overrides:
-  virtual void OnWindowBoundsChanged(aura::Window* window,
-                                     const gfx::Rect& old_bounds,
-                                     const gfx::Rect& new_bounds) override;
-  virtual void OnWindowDestroyed(aura::Window* window) override;
+  void OnWindowBoundsChanged(aura::Window* window,
+                             const gfx::Rect& old_bounds,
+                             const gfx::Rect& new_bounds) override;
+  void OnWindowDestroyed(aura::Window* window) override;
 
  private:
   friend class TestApi;
diff --git a/ui/keyboard/keyboard_controller_unittest.cc b/ui/keyboard/keyboard_controller_unittest.cc
index 9c3ccb6..b2db69c 100644
--- a/ui/keyboard/keyboard_controller_unittest.cc
+++ b/ui/keyboard/keyboard_controller_unittest.cc
@@ -62,13 +62,11 @@ class TestFocusController : public ui::EventHandler {
     root_->AddPreTargetHandler(this);
   }
 
-  virtual ~TestFocusController() {
-    root_->RemovePreTargetHandler(this);
-  }
+  ~TestFocusController() override { root_->RemovePreTargetHandler(this); }
 
  private:
   // Overridden from ui::EventHandler:
-  virtual void OnEvent(ui::Event* event) override {
+  void OnEvent(ui::Event* event) override {
     aura::Window* target = static_cast<aura::Window*>(event->target());
     if (event->type() == ui::ET_MOUSE_PRESSED ||
         event->type() == ui::ET_TOUCH_PRESSED) {
@@ -86,14 +84,14 @@ class TestKeyboardControllerProxy : public KeyboardControllerProxy {
       : input_method_(
             ui::CreateInputMethod(NULL, gfx::kNullAcceleratedWidget)) {}
 
-  virtual ~TestKeyboardControllerProxy() {
+  ~TestKeyboardControllerProxy() override {
     // Destroy the window before the delegate.
     window_.reset();
   }
 
   // Overridden from KeyboardControllerProxy:
-  virtual bool HasKeyboardWindow() const override { return window_; }
-  virtual aura::Window* GetKeyboardWindow() override {
+  bool HasKeyboardWindow() const override { return window_; }
+  aura::Window* GetKeyboardWindow() override {
     if (!window_) {
       window_.reset(new aura::Window(&delegate_));
       window_->Init(aura::WINDOW_LAYER_NOT_DRAWN);
@@ -101,15 +99,16 @@ class TestKeyboardControllerProxy : public KeyboardControllerProxy {
     }
     return window_.get();
   }
-  virtual content::BrowserContext* GetBrowserContext() override { return NULL; }
-  virtual ui::InputMethod* GetInputMethod() override {
-    return input_method_.get();
-  }
-  virtual void RequestAudioInput(content::WebContents* web_contents,
+  content::BrowserContext* GetBrowserContext() override { return NULL; }
+  ui::InputMethod* GetInputMethod() override { return input_method_.get(); }
+  void RequestAudioInput(
+      content::WebContents* web_contents,
       const content::MediaStreamRequest& request,
-      const content::MediaResponseCallback& callback) override { return; }
-  virtual void LoadSystemKeyboard() override {};
-  virtual void ReloadKeyboardIfNeeded() override {};
+      const content::MediaResponseCallback& callback) override {
+    return;
+  }
+  void LoadSystemKeyboard() override{};
+  void ReloadKeyboardIfNeeded() override{};
 
  private:
   scoped_ptr<aura::Window> window_;
@@ -123,7 +122,7 @@ class TestKeyboardControllerProxy : public KeyboardControllerProxy {
 class EventObserver : public ui::EventHandler {
  public:
   EventObserver() {}
-  virtual ~EventObserver() {}
+  ~EventObserver() override {}
 
   int GetEventCount(ui::EventType type) {
     return event_counts_[type];
@@ -131,7 +130,7 @@ class EventObserver : public ui::EventHandler {
 
  private:
   // Overridden from ui::EventHandler:
-  virtual void OnEvent(ui::Event* event) override {
+  void OnEvent(ui::Event* event) override {
     ui::EventHandler::OnEvent(event);
     event_counts_[event->type()]++;
   }
@@ -145,13 +144,10 @@ class KeyboardContainerObserver : public aura::WindowObserver {
   explicit KeyboardContainerObserver(aura::Window* window) : window_(window) {
     window_->AddObserver(this);
   }
-  virtual ~KeyboardContainerObserver() {
-    window_->RemoveObserver(this);
-  }
+  ~KeyboardContainerObserver() override { window_->RemoveObserver(this); }
 
  private:
-  virtual void OnWindowVisibilityChanged(aura::Window* window,
-                                         bool visible) override {
+  void OnWindowVisibilityChanged(aura::Window* window, bool visible) override {
     if (!visible)
       base::MessageLoop::current()->Quit();
   }
@@ -166,9 +162,9 @@ class KeyboardContainerObserver : public aura::WindowObserver {
 class KeyboardControllerTest : public testing::Test {
  public:
   KeyboardControllerTest() {}
-  virtual ~KeyboardControllerTest() {}
+  ~KeyboardControllerTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     // The ContextFactory must exist before any Compositors are created.
     bool enable_pixel_output = false;
     ui::ContextFactory* context_factory =
@@ -185,7 +181,7 @@ class KeyboardControllerTest : public testing::Test {
     controller_.reset(new KeyboardController(proxy_));
   }
 
-  virtual void TearDown() override {
+  void TearDown() override {
     controller_.reset();
     focus_controller_.reset();
     if (::switches::IsTextInputFocusManagerEnabled())
@@ -497,9 +493,9 @@ class KeyboardControllerAnimationTest : public KeyboardControllerTest,
                                         public KeyboardControllerObserver {
  public:
   KeyboardControllerAnimationTest() {}
-  virtual ~KeyboardControllerAnimationTest() {}
+  ~KeyboardControllerAnimationTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     // We cannot short-circuit animations for this test.
     ui::ScopedAnimationDurationScaleMode test_duration_mode(
         ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
@@ -512,14 +508,14 @@ class KeyboardControllerAnimationTest : public KeyboardControllerTest,
     controller()->AddObserver(this);
   }
 
-  virtual void TearDown() override {
+  void TearDown() override {
     controller()->RemoveObserver(this);
     KeyboardControllerTest::TearDown();
   }
 
  protected:
   // KeyboardControllerObserver overrides
-  virtual void OnKeyboardBoundsChanging(const gfx::Rect& new_bounds) override {
+  void OnKeyboardBoundsChanging(const gfx::Rect& new_bounds) override {
     notified_bounds_ = new_bounds;
   }
 
diff --git a/ui/keyboard/keyboard_layout_manager.h b/ui/keyboard/keyboard_layout_manager.h
index b93665f..1500d51 100644
--- a/ui/keyboard/keyboard_layout_manager.h
+++ b/ui/keyboard/keyboard_layout_manager.h
@@ -22,14 +22,14 @@ class KeyboardLayoutManager : public aura::LayoutManager {
   }
 
   // Overridden from aura::LayoutManager
-  virtual void OnWindowResized() override;
-  virtual void OnWindowAddedToLayout(aura::Window* child) override;
-  virtual void OnWillRemoveWindowFromLayout(aura::Window* child) override {}
-  virtual void OnWindowRemovedFromLayout(aura::Window* child) override {}
-  virtual void OnChildWindowVisibilityChanged(aura::Window* child,
-                                              bool visible) override {}
-  virtual void SetChildBounds(aura::Window* child,
-                              const gfx::Rect& requested_bounds) override;
+  void OnWindowResized() override;
+  void OnWindowAddedToLayout(aura::Window* child) override;
+  void OnWillRemoveWindowFromLayout(aura::Window* child) override {}
+  void OnWindowRemovedFromLayout(aura::Window* child) override {}
+  void OnChildWindowVisibilityChanged(aura::Window* child,
+                                      bool visible) override {}
+  void SetChildBounds(aura::Window* child,
+                      const gfx::Rect& requested_bounds) override;
 
  private:
   KeyboardController* controller_;
diff --git a/ui/keyboard/test/run_all_unittests.cc b/ui/keyboard/test/run_all_unittests.cc
index 519f69f..c81e199 100644
--- a/ui/keyboard/test/run_all_unittests.cc
+++ b/ui/keyboard/test/run_all_unittests.cc
@@ -20,7 +20,7 @@ class KeyboardTestSuite : public base::TestSuite {
   KeyboardTestSuite(int argc, char** argv) : base::TestSuite(argc, argv) {}
 
  protected:
-  virtual void Initialize() override {
+  void Initialize() override {
     base::TestSuite::Initialize();
     gfx::GLSurface::InitializeOneOffForTests();
     ui::RegisterPathProvider();
@@ -30,7 +30,7 @@ class KeyboardTestSuite : public base::TestSuite {
     ui::ResourceBundle::InitSharedInstanceWithPakPath(ui_test_pak_path);
   }
 
-  virtual void Shutdown() override {
+  void Shutdown() override {
     ui::ResourceBundle::CleanupSharedInstance();
     base::TestSuite::Shutdown();
   }
diff --git a/ui/keyboard/webui/vk_mojo_handler.h b/ui/keyboard/webui/vk_mojo_handler.h
index a7985db..5a25abd 100644
--- a/ui/keyboard/webui/vk_mojo_handler.h
+++ b/ui/keyboard/webui/vk_mojo_handler.h
@@ -15,33 +15,30 @@ class VKMojoHandler : public mojo::InterfaceImpl<KeyboardUIHandlerMojo>,
                       public ui::InputMethodObserver {
  public:
   VKMojoHandler();
-  virtual ~VKMojoHandler();
+  ~VKMojoHandler() override;
 
  private:
   ui::InputMethod* GetInputMethod();
 
   // mojo::InterfaceImpl<>:
-  virtual void OnConnectionEstablished() override;
+  void OnConnectionEstablished() override;
 
   // KeyboardUIHandlerMojo:
-  virtual void SendKeyEvent(const mojo::String& event_type,
-                            int32_t char_value,
-                            int32_t key_code,
-                            const mojo::String& key_name,
-                            int32_t modifiers) override;
-  virtual void HideKeyboard() override;
+  void SendKeyEvent(const mojo::String& event_type,
+                    int32_t char_value,
+                    int32_t key_code,
+                    const mojo::String& key_name,
+                    int32_t modifiers) override;
+  void HideKeyboard() override;
 
   // ui::InputMethodObserver:
-  virtual void OnTextInputTypeChanged(
-      const ui::TextInputClient* client) override;
-  virtual void OnFocus() override;
-  virtual void OnBlur() override;
-  virtual void OnCaretBoundsChanged(const ui::TextInputClient* client) override;
-  virtual void OnTextInputStateChanged(
-      const ui::TextInputClient* text_client) override;
-  virtual void OnInputMethodDestroyed(
-      const ui::InputMethod* input_method) override;
-  virtual void OnShowImeIfNeeded() override;
+  void OnTextInputTypeChanged(const ui::TextInputClient* client) override;
+  void OnFocus() override;
+  void OnBlur() override;
+  void OnCaretBoundsChanged(const ui::TextInputClient* client) override;
+  void OnTextInputStateChanged(const ui::TextInputClient* text_client) override;
+  void OnInputMethodDestroyed(const ui::InputMethod* input_method) override;
+  void OnShowImeIfNeeded() override;
 
   DISALLOW_COPY_AND_ASSIGN(VKMojoHandler);
 };
diff --git a/ui/keyboard/webui/vk_webui_controller.h b/ui/keyboard/webui/vk_webui_controller.h
index 97ee5a56..30d1e25 100644
--- a/ui/keyboard/webui/vk_webui_controller.h
+++ b/ui/keyboard/webui/vk_webui_controller.h
@@ -26,14 +26,14 @@ class VKMojoHandler;
 class VKWebUIController : public content::WebUIController {
  public:
   explicit VKWebUIController(content::WebUI* web_ui);
-  virtual ~VKWebUIController();
+  ~VKWebUIController() override;
 
  private:
   void CreateAndStoreUIHandler(
       mojo::InterfaceRequest<KeyboardUIHandlerMojo> request);
 
   // content::WebUIController:
-  virtual void RenderViewCreated(content::RenderViewHost* host) override;
+  void RenderViewCreated(content::RenderViewHost* host) override;
 
   scoped_ptr<VKMojoHandler> ui_handler_;
   base::WeakPtrFactory<VKWebUIController> weak_factory_;
@@ -45,14 +45,13 @@ class KEYBOARD_EXPORT VKWebUIControllerFactory
     : public content::WebUIControllerFactory {
  public:
   // WebUIControllerFactory:
-  virtual content::WebUI::TypeID GetWebUIType(
-      content::BrowserContext* browser_context,
-      const GURL& url) const override;
-  virtual bool UseWebUIForURL(content::BrowserContext* browser_context,
-                              const GURL& url) const override;
-  virtual bool UseWebUIBindingsForURL(content::BrowserContext* browser_context,
+  content::WebUI::TypeID GetWebUIType(content::BrowserContext* browser_context,
                                       const GURL& url) const override;
-  virtual content::WebUIController* CreateWebUIControllerForURL(
+  bool UseWebUIForURL(content::BrowserContext* browser_context,
+                      const GURL& url) const override;
+  bool UseWebUIBindingsForURL(content::BrowserContext* browser_context,
+                              const GURL& url) const override;
+  content::WebUIController* CreateWebUIControllerForURL(
       content::WebUI* web_ui,
       const GURL& url) const override;
 
@@ -60,7 +59,7 @@ class KEYBOARD_EXPORT VKWebUIControllerFactory
 
  protected:
   VKWebUIControllerFactory();
-  virtual ~VKWebUIControllerFactory();
+  ~VKWebUIControllerFactory() override;
 
  private:
   friend struct DefaultSingletonTraits<VKWebUIControllerFactory>;
diff --git a/ui/native_theme/native_theme_aura.h b/ui/native_theme/native_theme_aura.h
index 2bcfbed..2170134 100644
--- a/ui/native_theme/native_theme_aura.h
+++ b/ui/native_theme/native_theme_aura.h
@@ -22,42 +22,40 @@ class NATIVE_THEME_EXPORT NativeThemeAura : public FallbackTheme {
 
  protected:
   NativeThemeAura();
-  virtual ~NativeThemeAura();
+  ~NativeThemeAura() override;
 
   // Overridden from NativeThemeBase:
-  virtual void PaintMenuPopupBackground(
+  void PaintMenuPopupBackground(
       SkCanvas* canvas,
       const gfx::Size& size,
       const MenuBackgroundExtraParams& menu_background) const override;
-  virtual void PaintMenuItemBackground(
+  void PaintMenuItemBackground(
       SkCanvas* canvas,
       State state,
       const gfx::Rect& rect,
       const MenuListExtraParams& menu_list) const override;
-  virtual void PaintArrowButton(SkCanvas* gc,
-                                const gfx::Rect& rect,
-                                Part direction,
-                                State state) const override;
-  virtual void PaintScrollbarTrack(
-      SkCanvas* sk_canvas,
-      Part part,
-      State state,
-      const ScrollbarTrackExtraParams& extra_params,
-      const gfx::Rect& rect) const override;
-  virtual void PaintScrollbarThumb(SkCanvas* sk_canvas,
-                                   Part part,
-                                   State state,
-                                   const gfx::Rect& rect) const override;
-  virtual void PaintScrollbarCorner(SkCanvas* canvas,
-                                    State state,
-                                    const gfx::Rect& rect) const override;
-
-  virtual void PaintScrollbarThumbStateTransition(SkCanvas* canvas,
-                                                  State startState,
-                                                  State endState,
-                                                  double progress,
-                                                  const gfx::Rect& rect) const
-      override;
+  void PaintArrowButton(SkCanvas* gc,
+                        const gfx::Rect& rect,
+                        Part direction,
+                        State state) const override;
+  void PaintScrollbarTrack(SkCanvas* sk_canvas,
+                           Part part,
+                           State state,
+                           const ScrollbarTrackExtraParams& extra_params,
+                           const gfx::Rect& rect) const override;
+  void PaintScrollbarThumb(SkCanvas* sk_canvas,
+                           Part part,
+                           State state,
+                           const gfx::Rect& rect) const override;
+  void PaintScrollbarCorner(SkCanvas* canvas,
+                            State state,
+                            const gfx::Rect& rect) const override;
+
+  void PaintScrollbarThumbStateTransition(SkCanvas* canvas,
+                                          State startState,
+                                          State endState,
+                                          double progress,
+                                          const gfx::Rect& rect) const override;
 
   // Returns the NineImagePainter used to paint the specified state, creating if
   // necessary. If no image is provided for the specified state the normal state
diff --git a/ui/platform_window/x11/x11_window.h b/ui/platform_window/x11/x11_window.h
index 6e1184c..eb75912 100644
--- a/ui/platform_window/x11/x11_window.h
+++ b/ui/platform_window/x11/x11_window.h
@@ -21,7 +21,7 @@ class X11_WINDOW_EXPORT X11Window : public PlatformWindow,
                                     public PlatformEventDispatcher {
  public:
   explicit X11Window(PlatformWindowDelegate* delegate);
-  virtual ~X11Window();
+  ~X11Window() override;
 
  private:
   void Destroy();
@@ -29,23 +29,23 @@ class X11_WINDOW_EXPORT X11Window : public PlatformWindow,
   void ProcessXInput2Event(XEvent* xevent);
 
   // PlatformWindow:
-  virtual void Show() override;
-  virtual void Hide() override;
-  virtual void Close() override;
-  virtual void SetBounds(const gfx::Rect& bounds) override;
-  virtual gfx::Rect GetBounds() override;
-  virtual void SetCapture() override;
-  virtual void ReleaseCapture() override;
-  virtual void ToggleFullscreen() override;
-  virtual void Maximize() override;
-  virtual void Minimize() override;
-  virtual void Restore() override;
-  virtual void SetCursor(PlatformCursor cursor) override;
-  virtual void MoveCursorTo(const gfx::Point& location) override;
+  void Show() override;
+  void Hide() override;
+  void Close() override;
+  void SetBounds(const gfx::Rect& bounds) override;
+  gfx::Rect GetBounds() override;
+  void SetCapture() override;
+  void ReleaseCapture() override;
+  void ToggleFullscreen() override;
+  void Maximize() override;
+  void Minimize() override;
+  void Restore() override;
+  void SetCursor(PlatformCursor cursor) override;
+  void MoveCursorTo(const gfx::Point& location) override;
 
   // PlatformEventDispatcher:
-  virtual bool CanDispatchEvent(const PlatformEvent& event) override;
-  virtual uint32_t DispatchEvent(const PlatformEvent& event) override;
+  bool CanDispatchEvent(const PlatformEvent& event) override;
+  uint32_t DispatchEvent(const PlatformEvent& event) override;
 
   PlatformWindowDelegate* delegate_;
 
diff --git a/ui/snapshot/snapshot_aura_unittest.cc b/ui/snapshot/snapshot_aura_unittest.cc
index b5a2a66..02c1350 100644
--- a/ui/snapshot/snapshot_aura_unittest.cc
+++ b/ui/snapshot/snapshot_aura_unittest.cc
@@ -40,10 +40,9 @@ class TestPaintingWindowDelegate : public aura::test::TestWindowDelegate {
       : window_size_(window_size) {
   }
 
-  virtual ~TestPaintingWindowDelegate() {
-  }
+  ~TestPaintingWindowDelegate() override {}
 
-  virtual void OnPaint(gfx::Canvas* canvas) override {
+  void OnPaint(gfx::Canvas* canvas) override {
     for (int y = 0; y < window_size_.height(); ++y) {
       for (int x = 0; x < window_size_.width(); ++x)
         canvas->FillRect(gfx::Rect(x, y, 1, 1), GetExpectedColorForPoint(x, y));
@@ -82,9 +81,9 @@ size_t GetFailedPixelsCount(const gfx::Image& image) {
 class SnapshotAuraTest : public testing::Test {
  public:
   SnapshotAuraTest() {}
-  virtual ~SnapshotAuraTest() {}
+  ~SnapshotAuraTest() override {}
 
-  virtual void SetUp() override {
+  void SetUp() override {
     testing::Test::SetUp();
 
     // The ContextFactory must exist before any Compositors are created.
@@ -99,7 +98,7 @@ class SnapshotAuraTest : public testing::Test {
     new ::wm::DefaultActivationClient(helper_->root_window());
   }
 
-  virtual void TearDown() override {
+  void TearDown() override {
     test_window_.reset();
     delegate_.reset();
     helper_->RunAllPendingInMessageLoop();
diff --git a/ui/views_content_client/views_content_browser_client.h b/ui/views_content_client/views_content_browser_client.h
index a24ece9..98d9ee4 100644
--- a/ui/views_content_client/views_content_browser_client.h
+++ b/ui/views_content_client/views_content_browser_client.h
@@ -21,12 +21,12 @@ class ViewsContentBrowserClient : public content::ContentBrowserClient {
  public:
   explicit ViewsContentBrowserClient(
       ViewsContentClient* views_content_client);
-  virtual ~ViewsContentBrowserClient();
+  ~ViewsContentBrowserClient() override;
 
   // content::ContentBrowserClient:
-  virtual content::BrowserMainParts* CreateBrowserMainParts(
+  content::BrowserMainParts* CreateBrowserMainParts(
       const content::MainFunctionParams& parameters) override;
-  virtual net::URLRequestContextGetter* CreateRequestContext(
+  net::URLRequestContextGetter* CreateRequestContext(
       content::BrowserContext* browser_context,
       content::ProtocolHandlerMap* protocol_handlers,
       content::URLRequestInterceptorScopedVector request_interceptors) override;
diff --git a/ui/views_content_client/views_content_client_main_parts.h b/ui/views_content_client/views_content_client_main_parts.h
index 1e9ad4d..6c14d2f 100644
--- a/ui/views_content_client/views_content_client_main_parts.h
+++ b/ui/views_content_client/views_content_client_main_parts.h
@@ -29,12 +29,12 @@ class ViewsContentClientMainParts : public content::BrowserMainParts {
       const content::MainFunctionParams& content_params,
       ViewsContentClient* views_content_client);
 
-  virtual ~ViewsContentClientMainParts();
+  ~ViewsContentClientMainParts() override;
 
   // content::BrowserMainParts:
-  virtual void PreMainMessageLoopRun() override;
-  virtual bool MainMessageLoopRun(int* result_code) override;
-  virtual void PostMainMessageLoopRun() override;
+  void PreMainMessageLoopRun() override;
+  bool MainMessageLoopRun(int* result_code) override;
+  void PostMainMessageLoopRun() override;
 
   content::ShellBrowserContext* browser_context() {
     return browser_context_.get();
diff --git a/ui/views_content_client/views_content_client_main_parts_aura.h b/ui/views_content_client/views_content_client_main_parts_aura.h
index 4a8f56dc..84d0530 100644
--- a/ui/views_content_client/views_content_client_main_parts_aura.h
+++ b/ui/views_content_client/views_content_client_main_parts_aura.h
@@ -20,11 +20,11 @@ class ViewsContentClientMainPartsAura : public ViewsContentClientMainParts {
   ViewsContentClientMainPartsAura(
       const content::MainFunctionParams& content_params,
       ViewsContentClient* views_content_client);
-  virtual ~ViewsContentClientMainPartsAura();
+  ~ViewsContentClientMainPartsAura() override;
 
   // content::BrowserMainParts:
-  virtual void ToolkitInitialized() override;
-  virtual void PostMainMessageLoopRun() override;
+  void ToolkitInitialized() override;
+  void PostMainMessageLoopRun() override;
 
  private:
   scoped_ptr< ::wm::WMState> wm_state_;
diff --git a/ui/views_content_client/views_content_client_main_parts_desktop_aura.cc b/ui/views_content_client/views_content_client_main_parts_desktop_aura.cc
index cb2293b..93401e6 100644
--- a/ui/views_content_client/views_content_client_main_parts_desktop_aura.cc
+++ b/ui/views_content_client/views_content_client_main_parts_desktop_aura.cc
@@ -19,10 +19,10 @@ class ViewsContentClientMainPartsDesktopAura
   ViewsContentClientMainPartsDesktopAura(
       const content::MainFunctionParams& content_params,
       ViewsContentClient* views_content_client);
-  virtual ~ViewsContentClientMainPartsDesktopAura() {}
+  ~ViewsContentClientMainPartsDesktopAura() override {}
 
   // content::BrowserMainParts:
-  virtual void PreMainMessageLoopRun() override;
+  void PreMainMessageLoopRun() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ViewsContentClientMainPartsDesktopAura);
diff --git a/ui/views_content_client/views_content_main_delegate.h b/ui/views_content_client/views_content_main_delegate.h
index 646201a..51839f7 100644
--- a/ui/views_content_client/views_content_main_delegate.h
+++ b/ui/views_content_client/views_content_main_delegate.h
@@ -18,12 +18,12 @@ class ViewsContentClient;
 class ViewsContentMainDelegate : public content::ContentMainDelegate {
  public:
   explicit ViewsContentMainDelegate(ViewsContentClient* views_content_client);
-  virtual ~ViewsContentMainDelegate();
+  ~ViewsContentMainDelegate() override;
 
   // content::ContentMainDelegate implementation
-  virtual bool BasicStartupComplete(int* exit_code) override;
-  virtual void PreSandboxStartup() override;
-  virtual content::ContentBrowserClient* CreateContentBrowserClient() override;
+  bool BasicStartupComplete(int* exit_code) override;
+  void PreSandboxStartup() override;
+  content::ContentBrowserClient* CreateContentBrowserClient() override;
 
  private:
   scoped_ptr<ViewsContentBrowserClient> browser_client_;