Mojo: Convert the remaining OVERRIDEs to override in mojo/.

mojo/examples/media_viewer/media_viewer.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <map>
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 45 matching lines @@
         hot_painter_(CreatePainter(SkColorSetRGB(0xA0, 0xA0, 0xA0),
                                    SkColorSetRGB(0xD0, 0xD0, 0xD0))),
         pushed_painter_(CreatePainter(SkColorSetRGB(0x80, 0x80, 0x80),
                                       SkColorSetRGB(0x90, 0x90, 0x90))),
         insets_(2, 6, 2, 6) {
   }
   virtual ~CustomButtonBorder() {}
 
  private:
   // Overridden from views::Border:
-  virtual void Paint(const views::View& view, gfx::Canvas* canvas) OVERRIDE {
+  virtual void Paint(const views::View& view, gfx::Canvas* canvas) override {
     const views::LabelButton* button =
         static_cast<const views::LabelButton*>(&view);
     views::Button::ButtonState state = button->state();
 
     views::Painter* painter = normal_painter_.get();
     if (state == views::Button::STATE_HOVERED) {
       painter = hot_painter_.get();
     } else if (state == views::Button::STATE_PRESSED) {
       painter = pushed_painter_.get();
     }
     painter->Paint(canvas, view.size());
   }
 
-  virtual gfx::Insets GetInsets() const OVERRIDE {
+  virtual gfx::Insets GetInsets() const override {
     return insets_;
   }
 
-  virtual gfx::Size GetMinimumSize() const OVERRIDE {
+  virtual gfx::Size GetMinimumSize() const override {
     gfx::Size size;
     if (normal_painter_)
       size.SetToMax(normal_painter_->GetMinimumSize());
     if (hot_painter_)
       size.SetToMax(hot_painter_->GetMinimumSize());
     if (pushed_painter_)
       size.SetToMax(pushed_painter_->GetMinimumSize());
     return size;
   }
 
@@ skipping 69 matching lines @@
     params.delegate = widget_delegate;
     params.bounds = gfx::Rect(view->bounds().width(), view->bounds().height());
     params.opacity = views::Widget::InitParams::OPAQUE_WINDOW;
     widget->Init(params);
     widget->Show();
   }
 
  private:
   // Overridden from views::ButtonListener:
   virtual void ButtonPressed(views::Button* sender,
-                             const ui::Event& event) OVERRIDE {
+                             const ui::Event& event) override {
     for (int i = 0; i < CONTROL_COUNT; ++i) {
       if (sender == buttons_[i]) {
         delegate_->ButtonPressed(static_cast<ControlType>(i));
         return;
       }
     }
   }
 
   Delegate* delegate_;
   views::Button* buttons_[CONTROL_COUNT];
@@ skipping 20 matching lines @@
   virtual ~MediaViewer() {
     if (root_view_)
       root_view_->RemoveObserver(this);
   }
 
  private:
   typedef std::map<std::string, std::string> HandlerMap;
 
 
   // Overridden from ApplicationDelegate:
-  virtual void Initialize(ApplicationImpl* app) OVERRIDE {
+  virtual void Initialize(ApplicationImpl* app) override {
     view_manager_client_factory_.reset(
         new ViewManagerClientFactory(app->shell(), this));
     app_ = app;
     views_init_.reset(new ViewsInit);
   }
 
   virtual bool ConfigureIncomingConnection(ApplicationConnection* connection)
-      OVERRIDE {
+      override {
     connection->AddService(view_manager_client_factory_.get());
     return true;
   }
 
   void LayoutViews() {
     View* root = content_view_->parent();
     gfx::Rect control_bounds(root->bounds().width(), 28);
     control_view_->SetBounds(control_bounds);
     gfx::Rect content_bounds(0, control_bounds.height(), root->bounds().width(),
                              root->bounds().height() - control_bounds.height());
     content_view_->SetBounds(content_bounds);
   }
 
   // Overridden from ViewManagerDelegate:
   virtual void OnEmbed(ViewManager* view_manager,
                        View* root,
                        ServiceProviderImpl* exported_services,
-                       scoped_ptr<ServiceProvider> imported_services) OVERRIDE {
+                       scoped_ptr<ServiceProvider> imported_services) override {
     root_view_ = root;
     view_manager_ = view_manager;
 
     control_view_ = View::Create(view_manager_);
     root_view_->AddChild(control_view_);
 
     content_view_ = View::Create(view_manager_);
     root_view_->AddChild(content_view_);
 
     control_panel_.Initialize(control_view_);
 
     LayoutViews();
     root_view_->AddObserver(this);
 
     content_view_->Embed("TODO");
   }
 
   virtual void OnViewManagerDisconnected(
-      ViewManager* view_manager) OVERRIDE {
+      ViewManager* view_manager) override {
     DCHECK_EQ(view_manager_, view_manager);
     view_manager_ = NULL;
     base::MessageLoop::current()->Quit();
   }
 
   // Overridden from ControlPanel::Delegate:
-  virtual void ButtonPressed(ControlPanel::ControlType type) OVERRIDE {
+  virtual void ButtonPressed(ControlPanel::ControlType type) override {
     switch (type) {
       case ControlPanel::CONTROL_ZOOM_IN:
         zoomable_media_->ZoomIn();
         break;
       case ControlPanel::CONTROL_ACTUAL_SIZE:
        zoomable_media_->ZoomToActualSize();
         break;
       case ControlPanel::CONTROL_ZOOM_OUT:
         zoomable_media_->ZoomOut();
         break;
       default:
         NOTIMPLEMENTED();
     }
   }
 
   // ViewObserver:
   virtual void OnViewBoundsChanged(View* view,
                                    const gfx::Rect& old_bounds,
-                                   const gfx::Rect& new_bounds) OVERRIDE {
+                                   const gfx::Rect& new_bounds) override {
     LayoutViews();
   }
-  virtual void OnViewDestroyed(View* view) OVERRIDE {
+  virtual void OnViewDestroyed(View* view) override {
     DCHECK_EQ(view, root_view_);
     view->RemoveObserver(this);
     root_view_ = NULL;
   }
 
   std::string GetHandlerForContentType(const std::string& content_type) {
     HandlerMap::const_iterator it = handler_map_.find(content_type);
     return it != handler_map_.end() ? it->second : std::string();
   }
 
@@ skipping 12 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(MediaViewer);
 };
 
 }  // namespace examples
 }  // namespace mojo
 
 MojoResult MojoMain(MojoHandle shell_handle) {
   mojo::ApplicationRunnerChromium runner(new mojo::examples::MediaViewer);
   return runner.Run(shell_handle);
 }