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

mojo/examples/browser/browser.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/macros.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "mojo/application/application_runner_chromium.h"
 #include "mojo/common/common_type_converters.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/connect.h"
@@ skipping 21 matching lines @@
 namespace mojo {
 namespace examples {
 
 class BrowserLayoutManager : public views::LayoutManager {
  public:
   BrowserLayoutManager() {}
   virtual ~BrowserLayoutManager() {}
 
  private:
   // Overridden from views::LayoutManager:
-  virtual void Layout(views::View* host) OVERRIDE {
+  virtual void Layout(views::View* host) override {
     // Browser view has one child, a text input field.
     DCHECK_EQ(1, host->child_count());
     views::View* text_field = host->child_at(0);
     gfx::Size ps = text_field->GetPreferredSize();
     text_field->SetBoundsRect(gfx::Rect(host->width(), ps.height()));
   }
-  virtual gfx::Size GetPreferredSize(const views::View* host) const OVERRIDE {
+  virtual gfx::Size GetPreferredSize(const views::View* host) const override {
     return gfx::Size();
   }
 
   DISALLOW_COPY_AND_ASSIGN(BrowserLayoutManager);
 };
 
 // KeyboardManager handles notifying the windowmanager when views are focused.
 // To use create one and KeyboardManager will take care of all other details.
 //
 // TODO(sky): it would be nice if this were put in NativeWidgetViewManager, but
@@ skipping 43 matching lines @@
     if (!focused_view_)
       return;
 
     window_manager_->HideKeyboard(last_view_id_);
     last_view_id_ = 0;
     focused_view_ = NULL;
   }
 
   // views::FocusChangeListener:
   virtual void OnWillChangeFocus(views::View* focused_before,
-                                 views::View* focused_now) OVERRIDE {
+                                 views::View* focused_now) override {
   }
   virtual void OnDidChangeFocus(views::View* focused_before,
-                                views::View* focused_now) OVERRIDE {
+                                views::View* focused_now) override {
     if (focused_view_ && focused_now != focused_view_)
       HideKeyboard();
   }
 
   // ui::EventHandler:
-  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) override {
     views::View* focused_now = widget_->GetFocusManager()->GetFocusedView();
     if (focused_now &&
         focused_now->GetClassName() == views::Textfield::kViewClassName &&
         (event->flags() & ui::EF_FROM_TOUCH) != 0) {
       ShowKeyboard(focused_now);
     }
   }
 
   // views::WidgetObserver:
-  virtual void OnWidgetDestroying(views::Widget* widget) OVERRIDE {
+  virtual void OnWidgetDestroying(views::Widget* widget) override {
     delete this;
   }
 
   views::Widget* widget_;
   IWindowManager* window_manager_;
   View* view_;
   Id last_view_id_;
   views::View* focused_view_;
 
   DISALLOW_COPY_AND_ASSIGN(KeyboardManager);
@@ skipping 52 matching lines @@
     // KeyboardManager handles deleting itself when the widget is destroyed.
     new KeyboardManager(widget_, window_manager_.get(), view);
     widget_->Show();
     textfield->RequestFocus();
   }
 
   // ViewManagerDelegate:
   virtual void OnEmbed(ViewManager* view_manager,
                        View* root,
                        ServiceProviderImpl* exported_services,
-                       scoped_ptr<ServiceProvider> imported_services) OVERRIDE {
+                       scoped_ptr<ServiceProvider> imported_services) override {
     // TODO: deal with OnEmbed() being invoked multiple times.
     ConnectToService(imported_services.get(), &navigator_host_);
     view_manager_ = view_manager;
     root_ = root;
     root_->AddObserver(this);
     root_->SetFocus();
     CreateWidget(root_);
   }
   virtual void OnViewManagerDisconnected(
-      ViewManager* view_manager) OVERRIDE {
+      ViewManager* view_manager) override {
     DCHECK_EQ(view_manager_, view_manager);
     view_manager_ = NULL;
     base::MessageLoop::current()->Quit();
   }
 
   // views::TextfieldController:
   virtual bool HandleKeyEvent(views::Textfield* sender,
-                              const ui::KeyEvent& key_event) OVERRIDE {
+                              const ui::KeyEvent& key_event) override {
     if (key_event.key_code() == ui::VKEY_RETURN) {
       GURL url(sender->text());
       printf("User entered this URL: %s\n", url.spec().c_str());
       URLRequestPtr request(URLRequest::New());
       request->url = String::From(url);
       navigator_host_->RequestNavigate(TARGET_NEW_NODE, request.Pass());
     }
     return false;
   }
 
   // ViewObserver:
   virtual void OnViewFocusChanged(View* gained_focus,
-                                  View* lost_focus) OVERRIDE {
+                                  View* lost_focus) override {
     aura::client::FocusClient* focus_client =
         aura::client::GetFocusClient(widget_->GetNativeView());
     if (lost_focus == root_)
       focus_client->FocusWindow(NULL);
     else if (gained_focus == root_)
       focus_client->FocusWindow(widget_->GetNativeView());
   }
-  virtual void OnViewDestroyed(View* view) OVERRIDE {
+  virtual void OnViewDestroyed(View* view) override {
     DCHECK_EQ(root_, view);
     view->RemoveObserver(this);
     root_ = NULL;
   }
 
   scoped_ptr<ViewsInit> views_init_;
 
   ViewManager* view_manager_;
   scoped_ptr<ViewManagerClientFactory> view_manager_client_factory_;
   View* root_;
   views::Widget* widget_;
   NavigatorHostPtr navigator_host_;
   IWindowManagerPtr window_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(Browser);
 };
 
 }  // namespace examples
 }  // namespace mojo
 
 MojoResult MojoMain(MojoHandle shell_handle) {
   mojo::ApplicationRunnerChromium runner(new mojo::examples::Browser);
   return runner.Run(shell_handle);
 }