Replacing the OVERRIDE with override and FINAL with final in content/browser/geolocation

content/browser/geolocation/geolocation_provider_impl_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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string16.h"
@@ skipping 18 matching lines @@
   LocationProviderForTestArbitrator() : mock_arbitrator_(NULL) {}
   virtual ~LocationProviderForTestArbitrator() {}
 
   // Only valid for use on the geolocation thread.
   MockLocationArbitrator* mock_arbitrator() const {
     return mock_arbitrator_;
   }
 
  protected:
   // GeolocationProviderImpl implementation:
-  virtual LocationArbitrator* CreateArbitrator() OVERRIDE;
+  virtual LocationArbitrator* CreateArbitrator() override;
 
  private:
   MockLocationArbitrator* mock_arbitrator_;
 };
 
 LocationArbitrator* LocationProviderForTestArbitrator::CreateArbitrator() {
   DCHECK(mock_arbitrator_ == NULL);
   mock_arbitrator_ = new MockLocationArbitrator;
   return mock_arbitrator_;
 }
 
 class GeolocationObserver {
  public:
   virtual ~GeolocationObserver() {}
   virtual void OnLocationUpdate(const Geoposition& position) = 0;
 };
 
 class MockGeolocationObserver : public GeolocationObserver {
  public:
   MOCK_METHOD1(OnLocationUpdate, void(const Geoposition& position));
 };
 
 class AsyncMockGeolocationObserver : public MockGeolocationObserver {
  public:
-  virtual void OnLocationUpdate(const Geoposition& position) OVERRIDE {
+  virtual void OnLocationUpdate(const Geoposition& position) override {
     MockGeolocationObserver::OnLocationUpdate(position);
     base::MessageLoop::current()->Quit();
   }
 };
 
 class MockGeolocationCallbackWrapper {
  public:
   MOCK_METHOD1(Callback, void(const Geoposition& position));
 };
 
 class GeopositionEqMatcher
     : public MatcherInterface<const Geoposition&> {
  public:
   explicit GeopositionEqMatcher(const Geoposition& expected)
       : expected_(expected) {}
 
   virtual bool MatchAndExplain(const Geoposition& actual,
-                               MatchResultListener* listener) const OVERRIDE {
+                               MatchResultListener* listener) const override {
     return actual.latitude == expected_.latitude &&
            actual.longitude == expected_.longitude &&
            actual.altitude == expected_.altitude &&
            actual.accuracy == expected_.accuracy &&
            actual.altitude_accuracy == expected_.altitude_accuracy &&
            actual.heading == expected_.heading &&
            actual.speed == expected_.speed &&
            actual.timestamp == expected_.timestamp &&
            actual.error_code == expected_.error_code &&
            actual.error_message == expected_.error_message;
   }
 
-  virtual void DescribeTo(::std::ostream* os) const OVERRIDE {
+  virtual void DescribeTo(::std::ostream* os) const override {
     *os << "which matches the expected position";
   }
 
-  virtual void DescribeNegationTo(::std::ostream* os) const OVERRIDE {
+  virtual void DescribeNegationTo(::std::ostream* os) const override {
     *os << "which does not match the expected position";
   }
 
  private:
   Geoposition expected_;
 
   DISALLOW_COPY_AND_ASSIGN(GeopositionEqMatcher);
 };
 
 Matcher<const Geoposition&> GeopositionEq(const Geoposition& expected) {
@@ skipping 139 matching lines @@
       &MockGeolocationObserver::OnLocationUpdate,
       base::Unretained(&mock_observer));
   scoped_ptr<content::GeolocationProvider::Subscription> subscription =
       provider()->AddLocationUpdateCallback(callback, false);
   subscription.reset();
   // Wait for the providers to be stopped now that all clients are gone.
   EXPECT_FALSE(ProvidersStarted());
 }
 
 }  // namespace content