replace OVERRIDE and FINAL with override and final in mojo/

mojo/services/view_manager/view_manager_unittest.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 <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/auto_reset.h"
 #include "base/bind.h"
@@ skipping 258 matching lines @@
     main_run_loop_->Quit();
   }
 
   void GotViewTree(std::vector<TestView>* views, Array<ViewDataPtr> results) {
     ViewDatasToTestViews(results, views);
     DCHECK(main_run_loop_);
     main_run_loop_->Quit();
   }
 
   // TestChangeTracker::Delegate:
-  virtual void OnChangeAdded() OVERRIDE {
+  virtual void OnChangeAdded() override {
     if (quit_count_ > 0 && --quit_count_ == 0)
       QuitCountReached();
   }
 
   static ViewManagerProxy* instance_;
   static base::RunLoop* main_run_loop_;
   static bool in_embed_;
 
   TestChangeTracker* tracker_;
 
@@ skipping 22 matching lines @@
 bool ViewManagerProxy::in_embed_ = false;
 
 class TestViewManagerClientConnection
     : public InterfaceImpl<ViewManagerClient> {
  public:
   TestViewManagerClientConnection() : connection_(&tracker_) {
     tracker_.set_delegate(&connection_);
   }
 
   // InterfaceImpl:
-  virtual void OnConnectionEstablished() OVERRIDE {
+  virtual void OnConnectionEstablished() override {
     connection_.set_router(internal_state()->router());
     connection_.set_view_manager(client());
   }
 
   // ViewManagerClient:
   virtual void OnEmbed(
       ConnectionSpecificId connection_id,
       const String& creator_url,
       ViewDataPtr root,
-      InterfaceRequest<ServiceProvider> services) OVERRIDE {
+      InterfaceRequest<ServiceProvider> services) override {
     tracker_.OnEmbed(connection_id, creator_url, root.Pass());
   }
   virtual void OnViewBoundsChanged(Id view_id,
                                    RectPtr old_bounds,
-                                   RectPtr new_bounds) OVERRIDE {
+                                   RectPtr new_bounds) override {
     tracker_.OnViewBoundsChanged(view_id, old_bounds.Pass(), new_bounds.Pass());
   }
   virtual void OnViewHierarchyChanged(Id view,
                                       Id new_parent,
                                       Id old_parent,
-                                      Array<ViewDataPtr> views) OVERRIDE {
+                                      Array<ViewDataPtr> views) override {
     tracker_.OnViewHierarchyChanged(view, new_parent, old_parent, views.Pass());
   }
   virtual void OnViewReordered(Id view_id,
                                Id relative_view_id,
-                               OrderDirection direction) OVERRIDE {
+                               OrderDirection direction) override {
     tracker_.OnViewReordered(view_id, relative_view_id, direction);
   }
-  virtual void OnViewDeleted(Id view) OVERRIDE { tracker_.OnViewDeleted(view); }
-  virtual void OnViewVisibilityChanged(uint32_t view, bool visible) OVERRIDE {
+  virtual void OnViewDeleted(Id view) override { tracker_.OnViewDeleted(view); }
+  virtual void OnViewVisibilityChanged(uint32_t view, bool visible) override {
     tracker_.OnViewVisibilityChanged(view, visible);
   }
-  virtual void OnViewDrawnStateChanged(uint32_t view, bool drawn) OVERRIDE {
+  virtual void OnViewDrawnStateChanged(uint32_t view, bool drawn) override {
     tracker_.OnViewDrawnStateChanged(view, drawn);
   }
   virtual void OnViewInputEvent(Id view_id,
                                 EventPtr event,
-                                const Callback<void()>& callback) OVERRIDE {
+                                const Callback<void()>& callback) override {
     tracker_.OnViewInputEvent(view_id, event.Pass());
   }
   virtual void Embed(
       const String& url,
-      InterfaceRequest<ServiceProvider> service_provider) OVERRIDE {
+      InterfaceRequest<ServiceProvider> service_provider) override {
     tracker_.DelegateEmbed(url);
   }
-  virtual void DispatchOnViewInputEvent(mojo::EventPtr event) OVERRIDE {
+  virtual void DispatchOnViewInputEvent(mojo::EventPtr event) override {
   }
 
  private:
   TestChangeTracker tracker_;
   ViewManagerProxy connection_;
 
   DISALLOW_COPY_AND_ASSIGN(TestViewManagerClientConnection);
 };
 
 // Used with ViewManagerService::Embed(). Creates a
 // TestViewManagerClientConnection, which creates and owns the ViewManagerProxy.
 class EmbedApplicationLoader : public ApplicationLoader,
                                ApplicationDelegate,
                                public InterfaceFactory<ViewManagerClient> {
  public:
   EmbedApplicationLoader() {}
   virtual ~EmbedApplicationLoader() {}
 
   // ApplicationLoader implementation:
   virtual void Load(ApplicationManager* manager,
                     const GURL& url,
-                    scoped_refptr<LoadCallbacks> callbacks) OVERRIDE {
+                    scoped_refptr<LoadCallbacks> callbacks) override {
     ScopedMessagePipeHandle shell_handle = callbacks->RegisterApplication();
     if (!shell_handle.is_valid())
       return;
     scoped_ptr<ApplicationImpl> app(new ApplicationImpl(this,
                                                         shell_handle.Pass()));
     apps_.push_back(app.release());
   }
   virtual void OnApplicationError(ApplicationManager* manager,
-                                  const GURL& url) OVERRIDE {}
+                                  const GURL& url) override {}
 
   // ApplicationDelegate implementation:
   virtual bool ConfigureIncomingConnection(ApplicationConnection* connection)
-      OVERRIDE {
+      override {
     connection->AddService(this);
     return true;
   }
 
   // InterfaceFactory<ViewManagerClient> implementation:
   virtual void Create(ApplicationConnection* connection,
-                      InterfaceRequest<ViewManagerClient> request) OVERRIDE {
+                      InterfaceRequest<ViewManagerClient> request) override {
     BindToRequest(new TestViewManagerClientConnection, &request);
   }
 
  private:
   ScopedVector<ApplicationImpl> apps_;
 
   DISALLOW_COPY_AND_ASSIGN(EmbedApplicationLoader);
 };
 
 // Creates an id used for transport from the specified parameters.
@@ skipping 29 matching lines @@
 
 typedef std::vector<std::string> Changes;
 
 class ViewManagerTest : public testing::Test {
  public:
   ViewManagerTest()
       : connection_(NULL),
         connection2_(NULL),
         connection3_(NULL) {}
 
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     ASSERT_TRUE(ViewManagerProxy::IsInInitialState());
     test_helper_.Init();
 
 #if defined(OS_WIN)
     // As we unload the wndproc of window classes we need to be sure to
     // unregister them.
     gfx::WindowImpl::UnregisterClassesAtExit();
 #endif
 
     test_helper_.SetLoaderForURL(
         scoped_ptr<ApplicationLoader>(new EmbedApplicationLoader()),
         GURL(kTestServiceURL));
 
     test_helper_.SetLoaderForURL(
         scoped_ptr<ApplicationLoader>(new EmbedApplicationLoader()),
         GURL(kTestServiceURL2));
 
     test_helper_.application_manager()->ConnectToService(
         GURL("mojo:mojo_view_manager"), &view_manager_init_);
     ASSERT_TRUE(InitEmbed(view_manager_init_.get(), kTestServiceURL, 1));
 
     connection_ = ViewManagerProxy::WaitForInstance();
     ASSERT_TRUE(connection_ != NULL);
     connection_->DoRunLoopUntilChangesCount(1);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     if (connection3_)
       connection3_->Destroy();
     if (connection2_)
       connection2_->Destroy();
     if (connection_)
       connection_->Destroy();
   }
 
  protected:
   void EstablishSecondConnectionWithRoot(Id root_id) {
@@ skipping 927 matching lines @@
 
 // TODO(sky): add coverage of test that destroys connections and ensures other
 // connections get deletion notification.
 
 // TODO(sky): need to better track changes to initial connection. For example,
 // that SetBounsdViews/AddView and the like don't result in messages to the
 // originating connection.
 
 }  // namespace service
 }  // namespace mojo