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

content/renderer/media/mock_peer_connection_impl.cc

 // Copyright (c) 2012 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 "content/renderer/media/mock_peer_connection_impl.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
 
 using testing::_;
 using webrtc::AudioTrackInterface;
 using webrtc::CreateSessionDescriptionObserver;
 using webrtc::DtmfSenderInterface;
 using webrtc::DtmfSenderObserverInterface;
 using webrtc::IceCandidateInterface;
 using webrtc::MediaConstraintsInterface;
 using webrtc::MediaStreamInterface;
 using webrtc::PeerConnectionInterface;
 using webrtc::SessionDescriptionInterface;
 using webrtc::SetSessionDescriptionObserver;
 
 namespace content {
 
 class MockStreamCollection : public webrtc::StreamCollectionInterface {
  public:
-  virtual size_t count() override {
-    return streams_.size();
-  }
-  virtual MediaStreamInterface* at(size_t index) override {
-    return streams_[index];
-  }
-  virtual MediaStreamInterface* find(const std::string& label) override {
+  size_t count() override { return streams_.size(); }
+  MediaStreamInterface* at(size_t index) override { return streams_[index]; }
+  MediaStreamInterface* find(const std::string& label) override {
     for (size_t i = 0; i < streams_.size(); ++i) {
       if (streams_[i]->label() == label)
         return streams_[i];
     }
     return NULL;
   }
-  virtual webrtc::MediaStreamTrackInterface* FindAudioTrack(
+  webrtc::MediaStreamTrackInterface* FindAudioTrack(
       const std::string& id) override {
     for (size_t i = 0; i < streams_.size(); ++i) {
       webrtc::MediaStreamTrackInterface* track =
           streams_.at(i)->FindAudioTrack(id);
       if (track)
         return track;
     }
     return NULL;
   }
-  virtual webrtc::MediaStreamTrackInterface* FindVideoTrack(
+  webrtc::MediaStreamTrackInterface* FindVideoTrack(
       const std::string& id) override {
     for (size_t i = 0; i < streams_.size(); ++i) {
       webrtc::MediaStreamTrackInterface* track =
           streams_.at(i)->FindVideoTrack(id);
       if (track)
         return track;
     }
     return NULL;
   }
   void AddStream(MediaStreamInterface* stream) {
     streams_.push_back(stream);
   }
   void RemoveStream(MediaStreamInterface* stream) {
     StreamVector::iterator it = streams_.begin();
     for (; it != streams_.end(); ++it) {
       if (it->get() == stream) {
         streams_.erase(it);
         break;
       }
     }
   }
 
  protected:
-  virtual ~MockStreamCollection() {}
+  ~MockStreamCollection() override {}
 
  private:
   typedef std::vector<rtc::scoped_refptr<MediaStreamInterface> >
       StreamVector;
   StreamVector streams_;
 };
 
 class MockDataChannel : public webrtc::DataChannelInterface {
  public:
   MockDataChannel(const std::string& label,
                   const webrtc::DataChannelInit* config)
       : label_(label),
         reliable_(config->reliable),
         state_(webrtc::DataChannelInterface::kConnecting),
         config_(*config) {
   }
 
-  virtual void RegisterObserver(
-      webrtc::DataChannelObserver* observer) override {
-  }
+  void RegisterObserver(webrtc::DataChannelObserver* observer) override {}
 
-  virtual void UnregisterObserver() override {
-  }
+  void UnregisterObserver() override {}
 
-  virtual std::string label() const override {
-    return label_;
-  }
+  std::string label() const override { return label_; }
 
-  virtual bool reliable() const override {
-    return reliable_;
-  }
+  bool reliable() const override { return reliable_; }
 
-  virtual bool ordered() const override {
-    return config_.ordered;
-  }
+  bool ordered() const override { return config_.ordered; }
 
-  virtual unsigned short maxRetransmitTime() const override {
+  unsigned short maxRetransmitTime() const override {
     return config_.maxRetransmitTime;
   }
 
-  virtual unsigned short maxRetransmits() const override {
+  unsigned short maxRetransmits() const override {
     return config_.maxRetransmits;
   }
 
-  virtual std::string protocol() const override {
-    return config_.protocol;
-  }
+  std::string protocol() const override { return config_.protocol; }
 
-  virtual bool negotiated() const override {
-    return config_.negotiated;
-  }
+  bool negotiated() const override { return config_.negotiated; }
 
-  virtual int id() const override {
+  int id() const override {
     NOTIMPLEMENTED();
     return 0;
   }
 
-  virtual DataState state() const override {
-    return state_;
-  }
+  DataState state() const override { return state_; }
 
-  virtual uint64 buffered_amount() const override {
+  uint64 buffered_amount() const override {
     NOTIMPLEMENTED();
     return 0;
   }
 
-  virtual void Close() override {
-    state_ = webrtc::DataChannelInterface::kClosing;
-  }
+  void Close() override { state_ = webrtc::DataChannelInterface::kClosing; }
 
-  virtual bool Send(const webrtc::DataBuffer& buffer) override {
+  bool Send(const webrtc::DataBuffer& buffer) override {
     return state_ == webrtc::DataChannelInterface::kOpen;
   }
 
  protected:
-  virtual ~MockDataChannel() {}
+  ~MockDataChannel() override {}
 
  private:
   std::string label_;
   bool reliable_;
   webrtc::DataChannelInterface::DataState state_;
   webrtc::DataChannelInit config_;
 };
 
 class MockDtmfSender : public DtmfSenderInterface {
  public:
   explicit MockDtmfSender(AudioTrackInterface* track)
       : track_(track),
         observer_(NULL),
         duration_(0),
         inter_tone_gap_(0) {}
-  virtual void RegisterObserver(
-      DtmfSenderObserverInterface* observer) override {
+  void RegisterObserver(DtmfSenderObserverInterface* observer) override {
     observer_ = observer;
   }
-  virtual void UnregisterObserver() override {
-    observer_ = NULL;
-  }
-  virtual bool CanInsertDtmf() override {
-    return true;
-  }
-  virtual bool InsertDtmf(const std::string& tones, int duration,
-                          int inter_tone_gap) override {
+  void UnregisterObserver() override { observer_ = NULL; }
+  bool CanInsertDtmf() override { return true; }
+  bool InsertDtmf(const std::string& tones,
+                  int duration,
+                  int inter_tone_gap) override {
     tones_ = tones;
     duration_ = duration;
     inter_tone_gap_ = inter_tone_gap;
     return true;
   }
-  virtual const AudioTrackInterface* track() const override {
-    return track_.get();
-  }
-  virtual std::string tones() const override {
-    return tones_;
-  }
-  virtual int duration() const override { return duration_; }
-  virtual int inter_tone_gap() const override { return inter_tone_gap_; }
+  const AudioTrackInterface* track() const override { return track_.get(); }
+  std::string tones() const override { return tones_; }
+  int duration() const override { return duration_; }
+  int inter_tone_gap() const override { return inter_tone_gap_; }
 
  protected:
-  virtual ~MockDtmfSender() {}
+  ~MockDtmfSender() override {}
 
  private:
   rtc::scoped_refptr<AudioTrackInterface> track_;
   DtmfSenderObserverInterface* observer_;
   std::string tones_;
   int duration_;
   int inter_tone_gap_;
 };
 
 const char MockPeerConnectionImpl::kDummyOffer[] = "dummy offer";
@@ skipping 154 matching lines @@
   sdp_mline_index_ = candidate->sdp_mline_index();
   return candidate->ToString(&ice_sdp_);
 }
 
 void MockPeerConnectionImpl::RegisterUMAObserver(
     webrtc::UMAObserver* observer) {
   NOTIMPLEMENTED();
 }
 
 }  // namespace content