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

mojo/examples/window_manager/window_manager.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 "base/basictypes.h"
 #include "base/bind.h"
+#include "base/macros.h"
 #include "mojo/application/application_runner_chromium.h"
 #include "mojo/examples/keyboard/keyboard.mojom.h"
 #include "mojo/examples/window_manager/debug_panel.h"
 #include "mojo/examples/window_manager/window_manager.mojom.h"
 #include "mojo/public/c/system/main.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
 #include "mojo/public/cpp/application/interface_factory_impl.h"
 #include "mojo/public/cpp/application/service_provider_impl.h"
@@ skipping 90 matching lines @@
 }  // namespace
 
 class WindowManagerConnection : public InterfaceImpl<IWindowManager> {
  public:
   explicit WindowManagerConnection(WindowManager* window_manager)
       : window_manager_(window_manager) {}
   virtual ~WindowManagerConnection() {}
 
  private:
   // Overridden from IWindowManager:
-  virtual void CloseWindow(Id view_id) OVERRIDE;
-  virtual void ShowKeyboard(Id view_id, RectPtr bounds) OVERRIDE;
-  virtual void HideKeyboard(Id view_id) OVERRIDE;
+  virtual void CloseWindow(Id view_id) override;
+  virtual void ShowKeyboard(Id view_id, RectPtr bounds) override;
+  virtual void HideKeyboard(Id view_id) override;
 
   WindowManager* window_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowManagerConnection);
 };
 
 class NavigatorHostImpl : public InterfaceImpl<NavigatorHost> {
  public:
   explicit NavigatorHostImpl(WindowManager* window_manager, Id view_id)
       : window_manager_(window_manager), view_id_(view_id) {}
   virtual ~NavigatorHostImpl() {
   }
 
  private:
-  virtual void DidNavigateLocally(const mojo::String& url) OVERRIDE;
-  virtual void RequestNavigate(Target target, URLRequestPtr request) OVERRIDE;
+  virtual void DidNavigateLocally(const mojo::String& url) override;
+  virtual void RequestNavigate(Target target, URLRequestPtr request) override;
 
   WindowManager* window_manager_;
   Id view_id_;
 
   DISALLOW_COPY_AND_ASSIGN(NavigatorHostImpl);
 };
 
 class KeyboardManager : public KeyboardClient,
                         public ViewObserver {
  public:
@@ skipping 27 matching lines @@
 
   void Hide(Id view_id) {
     keyboard_service_->SetTarget(0);
     view_->SetVisible(false);
   }
 
  private:
   // KeyboardClient:
   virtual void OnKeyboardEvent(Id view_id,
                                int32_t code,
-                               int32_t flags) OVERRIDE {
+                               int32_t flags) override {
     View* view = view_manager_->GetViewById(view_id);
     if (!view)
       return;
 #if defined(OS_WIN)
     const bool is_char = code != ui::VKEY_BACK && code != ui::VKEY_RETURN;
 #else
     const bool is_char = false;
 #endif
     if (is_char) {
       view_manager_->DispatchEvent(
@@ skipping 11 matching lines @@
     view_manager_->DispatchEvent(
         view,
         Event::From(ui::KeyEvent(ui::ET_KEY_RELEASED,
                                  static_cast<ui::KeyboardCode>(code),
                                  flags)));
   }
 
   // Overridden from ViewObserver:
   virtual void OnViewBoundsChanged(View* parent,
                                    const gfx::Rect& old_bounds,
-                                   const gfx::Rect& new_bounds) OVERRIDE {
+                                   const gfx::Rect& new_bounds) override {
     gfx::Rect keyboard_bounds(view_->bounds());
     keyboard_bounds.set_y(new_bounds.bottom() - keyboard_bounds.height());
     keyboard_bounds.set_width(keyboard_bounds.width() +
                               new_bounds.width() - old_bounds.width());
     view_->SetBounds(keyboard_bounds);
   }
-  virtual void OnViewDestroyed(View* parent) OVERRIDE {
+  virtual void OnViewDestroyed(View* parent) override {
     DCHECK_EQ(parent, view_->parent());
     parent->RemoveObserver(this);
     view_ = NULL;
   }
 
   KeyboardServicePtr keyboard_service_;
   ViewManager* view_manager_;
 
   // View the keyboard is attached to.
   View* view_;
@@ skipping 15 matching lines @@
         control_panel_view_id_(control_panel_view_id) {}
   virtual ~RootLayoutManager() {
     if (root_)
       root_->RemoveObserver(this);
   }
 
  private:
   // Overridden from ViewObserver:
   virtual void OnViewBoundsChanged(View* view,
                                    const gfx::Rect& old_bounds,
-                                   const gfx::Rect& new_bounds) OVERRIDE {
+                                   const gfx::Rect& new_bounds) override {
     DCHECK_EQ(view, root_);
 
     View* content_view = view_manager_->GetViewById(content_view_id_);
     content_view->SetBounds(new_bounds);
 
     int delta_width = new_bounds.width() - old_bounds.width();
     int delta_height = new_bounds.height() - old_bounds.height();
 
     View* launcher_ui_view =
         view_manager_->GetViewById(launcher_ui_view_id_);
@@ skipping 13 matching lines @@
       View* view = *iter;
       if (view->id() == control_panel_view->id() ||
           view->id() == launcher_ui_view->id())
         continue;
       gfx::Rect view_bounds(view->bounds());
       view_bounds.set_width(view_bounds.width() + delta_width);
       view_bounds.set_height(view_bounds.height() + delta_height);
       view->SetBounds(view_bounds);
     }
   }
-  virtual void OnViewDestroyed(View* view) OVERRIDE {
+  virtual void OnViewDestroyed(View* view) override {
     DCHECK_EQ(view, root_);
     root_->RemoveObserver(this);
     root_ = NULL;
   }
 
   View* root_;
   ViewManager* view_manager_;
   const Id content_view_id_;
   const Id launcher_ui_view_id_;
   const Id control_panel_view_id_;
@@ skipping 13 matching lines @@
   void Embed(const std::string& url) {
     scoped_ptr<ServiceProviderImpl> service_provider_impl(
         new ServiceProviderImpl());
     service_provider_impl->AddService<NavigatorHost>(this);
     view_->Embed(url, service_provider_impl.Pass());
   }
 
  private:
   // InterfaceFactory<NavigatorHost>
   virtual void Create(ApplicationConnection* connection,
-                      InterfaceRequest<NavigatorHost> request) OVERRIDE {
+                      InterfaceRequest<NavigatorHost> request) override {
     BindToRequest(new NavigatorHostImpl(window_manager_, view_->id()),
                   &request);
   }
 
   WindowManager* window_manager_;
   View* view_;
 };
 
 class WindowManager
     : public ApplicationDelegate,
@@ skipping 48 matching lines @@
     if (keyboard_manager_)
       keyboard_manager_->Hide(view_id);
   }
 
   void DidNavigateLocally(uint32 source_view_id, const mojo::String& url) {
     LOG(ERROR) << "DidNavigateLocally: source_view_id: " << source_view_id
                << " url: " << url.To<std::string>();
   }
 
   // Overridden from DebugPanel::Delegate:
-  virtual void CloseTopWindow() OVERRIDE {
+  virtual void CloseTopWindow() override {
     if (!windows_.empty())
       CloseWindow(windows_.back()->view()->id());
   }
 
   virtual void RequestNavigate(uint32 source_view_id,
                                Target target,
-                               URLRequestPtr request) OVERRIDE {
+                               URLRequestPtr request) override {
     OnLaunch(source_view_id, target, request->url);
   }
 
  private:
   typedef std::vector<Window*> WindowVector;
 
   // Overridden from ApplicationDelegate:
   virtual void Initialize(ApplicationImpl* app) override {
     app_ = app;
     views_init_.reset(new ViewsInit);
     window_manager_app_->Initialize(app);
   }
 
   virtual bool ConfigureIncomingConnection(
       ApplicationConnection* connection) override {
     connection->AddService(&window_manager_factory_);
     window_manager_app_->ConfigureIncomingConnection(connection);
     return true;
   }
 
   // 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 {
     DCHECK(!view_manager_);
     view_manager_ = view_manager;
 
     View* view = View::Create(view_manager_);
     root->AddChild(view);
     view->SetBounds(gfx::Rect(root->bounds().size()));
     content_view_id_ = view->id();
 
     Id launcher_ui_id = CreateLauncherUI();
     Id control_panel_id = CreateControlPanel(view);
 
     root_layout_manager_.reset(
         new RootLayoutManager(view_manager, root,
                               content_view_id_,
                               launcher_ui_id,
                               control_panel_id));
     root->AddObserver(root_layout_manager_.get());
 
     window_manager_app_->host()->window()->AddPreTargetHandler(this);
 
     window_manager_app_->InitFocus(new WMFocusRules(window_manager_app_.get(),
                                                     view));
   }
-  virtual void OnViewManagerDisconnected(ViewManager* view_manager) OVERRIDE {
+  virtual void OnViewManagerDisconnected(ViewManager* view_manager) override {
     DCHECK_EQ(view_manager_, view_manager);
     view_manager_ = NULL;
     base::MessageLoop::current()->Quit();
   }
 
   // Overridden from WindowManagerDelegate:
   virtual void Embed(
       const String& url,
-      InterfaceRequest<ServiceProvider> service_provider) OVERRIDE {
+      InterfaceRequest<ServiceProvider> service_provider) override {
     const Id kInvalidSourceViewId = 0;
     OnLaunch(kInvalidSourceViewId, TARGET_DEFAULT, url);
   }
   virtual void DispatchEvent(EventPtr event) override {}
 
   // Overridden from ui::EventHandler:
-  virtual void OnEvent(ui::Event* event) OVERRIDE {
+  virtual void OnEvent(ui::Event* event) override {
     View* view = WindowManagerApp::GetViewForWindow(
         static_cast<aura::Window*>(event->target()));
     if (event->type() == ui::ET_MOUSE_PRESSED &&
         !IsDescendantOfKeyboard(view)) {
       view->SetFocus();
     }
   }
 
   void OnLaunch(uint32 source_view_id,
                 Target requested_target,
@@ skipping 136 matching lines @@
   window_manager_->RequestNavigate(view_id_, target, request.Pass());
 }
 
 }  // namespace examples
 }  // namespace mojo
 
 MojoResult MojoMain(MojoHandle shell_handle) {
   mojo::ApplicationRunnerChromium runner(new mojo::examples::WindowManager);
   return runner.Run(shell_handle);
 }