replace OVERRIDE and FINAL with override and final in media/

media/cdm/ppapi/cdm_wrapper.h

 // Copyright 2013 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.
 
 #ifndef MEDIA_CDM_PPAPI_CDM_WRAPPER_H_
 #define MEDIA_CDM_PPAPI_CDM_WRAPPER_H_
 
 #include <map>
 #include <queue>
 #include <string>
@@ skipping 164 matching lines @@
   bool HasHeader(const uint8* data,
                  int data_length,
                  const std::string& header) {
     return static_cast<size_t>(data_length) > header.length() &&
            std::equal(data, data + header.length(), header.begin());
   }
 
   virtual bool SetServerCertificate(
       uint32_t promise_id,
       const uint8_t* server_certificate_data,
-      uint32_t server_certificate_data_size) OVERRIDE {
+      uint32_t server_certificate_data_size) override {
     cdm_->SetServerCertificate(
         promise_id, server_certificate_data, server_certificate_data_size);
     return true;
   }
 
   virtual void CreateSession(uint32_t promise_id,
                              const char* init_data_type,
                              uint32_t init_data_type_size,
                              const uint8_t* init_data,
                              uint32_t init_data_size,
-                             cdm::SessionType session_type) OVERRIDE {
+                             cdm::SessionType session_type) override {
     // TODO(jrummell): Remove this code once |session_type| is passed through
     // Pepper. When removing, add the header back in for CDM4.
     PP_DCHECK(session_type == cdm::kTemporary);
     const char kPersistentSessionHeader[] = "PERSISTENT|";
     if (HasHeader(init_data, init_data_size, kPersistentSessionHeader)) {
       cdm_->CreateSession(promise_id,
                           init_data_type,
                           init_data_type_size,
                           init_data + strlen(kPersistentSessionHeader),
                           init_data_size - strlen(kPersistentSessionHeader),
                           cdm::kPersistent);
       return;
     }
 
     cdm_->CreateSession(promise_id,
                         init_data_type,
                         init_data_type_size,
                         init_data,
                         init_data_size,
                         session_type);
   }
 
   virtual void LoadSession(uint32_t promise_id,
                            const char* web_session_id,
-                           uint32_t web_session_id_size) OVERRIDE {
+                           uint32_t web_session_id_size) override {
     cdm_->LoadSession(promise_id, web_session_id, web_session_id_size);
   }
 
   virtual void UpdateSession(uint32_t promise_id,
                              const char* web_session_id,
                              uint32_t web_session_id_size,
                              const uint8_t* response,
-                             uint32_t response_size) OVERRIDE {
+                             uint32_t response_size) override {
     cdm_->UpdateSession(promise_id,
                         web_session_id,
                         web_session_id_size,
                         response,
                         response_size);
   }
 
   virtual bool CloseSession(uint32_t promise_id,
                             const char* web_session_id,
-                            uint32_t web_session_id_size) OVERRIDE {
+                            uint32_t web_session_id_size) override {
     cdm_->CloseSession(promise_id, web_session_id, web_session_id_size);
     return true;
   }
 
   virtual void RemoveSession(uint32_t promise_id,
                              const char* web_session_id,
-                             uint32_t web_session_id_size) OVERRIDE {
+                             uint32_t web_session_id_size) override {
     cdm_->RemoveSession(promise_id, web_session_id, web_session_id_size);
   }
 
   virtual bool GetUsableKeyIds(uint32_t promise_id,
                                const char* web_session_id,
-                               uint32_t web_session_id_size) OVERRIDE {
+                               uint32_t web_session_id_size) override {
     cdm_->GetUsableKeyIds(promise_id, web_session_id, web_session_id_size);
     return true;
   }
 
-  virtual void TimerExpired(void* context) OVERRIDE {
+  virtual void TimerExpired(void* context) override {
     cdm_->TimerExpired(context);
   }
 
   virtual cdm::Status Decrypt(const cdm::InputBuffer& encrypted_buffer,
-                              cdm::DecryptedBlock* decrypted_buffer) OVERRIDE {
+                              cdm::DecryptedBlock* decrypted_buffer) override {
     return cdm_->Decrypt(encrypted_buffer, decrypted_buffer);
   }
 
   virtual cdm::Status InitializeAudioDecoder(
-      const cdm::AudioDecoderConfig& audio_decoder_config) OVERRIDE {
+      const cdm::AudioDecoderConfig& audio_decoder_config) override {
     return cdm_->InitializeAudioDecoder(audio_decoder_config);
   }
 
   virtual cdm::Status InitializeVideoDecoder(
-      const cdm::VideoDecoderConfig& video_decoder_config) OVERRIDE {
+      const cdm::VideoDecoderConfig& video_decoder_config) override {
     return cdm_->InitializeVideoDecoder(video_decoder_config);
   }
 
-  virtual void DeinitializeDecoder(cdm::StreamType decoder_type) OVERRIDE {
+  virtual void DeinitializeDecoder(cdm::StreamType decoder_type) override {
     cdm_->DeinitializeDecoder(decoder_type);
   }
 
-  virtual void ResetDecoder(cdm::StreamType decoder_type) OVERRIDE {
+  virtual void ResetDecoder(cdm::StreamType decoder_type) override {
     cdm_->ResetDecoder(decoder_type);
   }
 
   virtual cdm::Status DecryptAndDecodeFrame(
       const cdm::InputBuffer& encrypted_buffer,
-      cdm::VideoFrame* video_frame) OVERRIDE {
+      cdm::VideoFrame* video_frame) override {
     return cdm_->DecryptAndDecodeFrame(encrypted_buffer, video_frame);
   }
 
   virtual cdm::Status DecryptAndDecodeSamples(
       const cdm::InputBuffer& encrypted_buffer,
-      cdm::AudioFrames* audio_frames) OVERRIDE {
+      cdm::AudioFrames* audio_frames) override {
     return cdm_->DecryptAndDecodeSamples(encrypted_buffer, audio_frames);
   }
 
   virtual void OnPlatformChallengeResponse(
-      const cdm::PlatformChallengeResponse& response) OVERRIDE {
+      const cdm::PlatformChallengeResponse& response) override {
     cdm_->OnPlatformChallengeResponse(response);
   }
 
   virtual void OnQueryOutputProtectionStatus(
       uint32_t link_mask,
-      uint32_t output_protection_mask) OVERRIDE {
+      uint32_t output_protection_mask) override {
     cdm_->OnQueryOutputProtectionStatus(link_mask, output_protection_mask);
   }
 
   uint32_t CreateSessionId() {
     return next_session_id_++;
   }
 
   void RegisterPromise(uint32_t session_id, uint32_t promise_id) {
     PP_DCHECK(promise_to_session_id_map_.find(session_id) ==
               promise_to_session_id_map_.end());
@@ skipping 257 matching lines @@
 // stub implementations for new or modified methods that the older CDM interface
 // does not have.
 // Also update supported_cdm_versions.h.
 COMPILE_ASSERT(cdm::ContentDecryptionModule::kVersion ==
                    cdm::ContentDecryptionModule_6::kVersion,
                ensure_cdm_wrapper_templates_have_old_version_support);
 
 }  // namespace media
 
 #endif  // MEDIA_CDM_PPAPI_CDM_WRAPPER_H_