Standardize usage of virtual/override/final in content/browser/

content/browser/device_sensors/device_inertial_sensor_browsertest.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/command_line.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "content/browser/device_sensors/data_fetcher_shared_memory.h"
 #include "content/browser/device_sensors/device_inertial_sensor_service.h"
 #include "content/common/device_sensors/device_light_hardware_buffer.h"
@@ skipping 16 matching lines @@
 class FakeDataFetcher : public DataFetcherSharedMemory {
  public:
   FakeDataFetcher()
       : started_orientation_(false, false),
         stopped_orientation_(false, false),
         started_motion_(false, false),
         stopped_motion_(false, false),
         started_light_(false, false),
         stopped_light_(false, false),
         sensor_data_available_(true) {}
-  virtual ~FakeDataFetcher() { }
+  ~FakeDataFetcher() override {}
 
-  virtual bool Start(ConsumerType consumer_type, void* buffer) override {
+  bool Start(ConsumerType consumer_type, void* buffer) override {
     EXPECT_TRUE(buffer);
 
     switch (consumer_type) {
       case CONSUMER_TYPE_MOTION:
         {
           DeviceMotionHardwareBuffer* motion_buffer =
               static_cast<DeviceMotionHardwareBuffer*>(buffer);
           if (sensor_data_available_)
             UpdateMotion(motion_buffer);
           SetMotionBufferReady(motion_buffer);
@@ skipping 20 matching lines @@
                           : std::numeric_limits<double>::infinity());
           started_light_.Signal();
         }
         break;
       default:
         return false;
     }
     return true;
   }
 
-  virtual bool Stop(ConsumerType consumer_type) override {
+  bool Stop(ConsumerType consumer_type) override {
     switch (consumer_type) {
       case CONSUMER_TYPE_MOTION:
         stopped_motion_.Signal();
         break;
       case CONSUMER_TYPE_ORIENTATION:
         stopped_orientation_.Signal();
         break;
       case CONSUMER_TYPE_LIGHT:
         stopped_light_.Signal();
         break;
       default:
         return false;
     }
     return true;
   }
 
-  virtual void Fetch(unsigned consumer_bitmask) override {
+  void Fetch(unsigned consumer_bitmask) override {
     FAIL() << "fetch should not be called";
   }
 
-  virtual FetcherType GetType() const override {
-    return FETCHER_TYPE_DEFAULT;
-  }
+  FetcherType GetType() const override { return FETCHER_TYPE_DEFAULT; }
 
   void SetSensorDataAvailable(bool available) {
     sensor_data_available_ = available;
   }
 
   void SetMotionBufferReady(DeviceMotionHardwareBuffer* buffer) {
     buffer->seqlock.WriteBegin();
     buffer->data.allAvailableSensorsAreActive = true;
     buffer->seqlock.WriteEnd();
   }
@@ skipping 63 matching lines @@
 };
 
 
 class DeviceInertialSensorBrowserTest : public ContentBrowserTest  {
  public:
   DeviceInertialSensorBrowserTest()
       : fetcher_(NULL),
         io_loop_finished_event_(false, false) {
   }
 
-  virtual void SetUpOnMainThread() override {
+  void SetUpOnMainThread() override {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&DeviceInertialSensorBrowserTest::SetUpOnIOThread, this));
     io_loop_finished_event_.Wait();
   }
 
   void SetUpOnIOThread() {
     fetcher_ = new FakeDataFetcher();
     DeviceInertialSensorService::GetInstance()->
         SetDataFetcherForTesting(fetcher_);
@@ skipping 153 matching lines @@
 
   fetcher_->started_motion_.Wait();
   fetcher_->stopped_motion_.Wait();
   same_tab_observer.Wait();
   EXPECT_EQ("pass", shell()->web_contents()->GetLastCommittedURL().ref());
 }
 
 }  //  namespace
 
 }  //  namespace content