media: Use native CDM enum types in media mojo interfaces

media/mojo/clients/mojo_decryptor.cc

 // Copyright 2015 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 "media/mojo/clients/mojo_decryptor.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 158 matching lines @@
 }
 
 void MojoDecryptor::OnBufferDecrypted(const DecryptCB& decrypt_cb,
                                       Status status,
                                       mojom::DecoderBufferPtr buffer) {
   DVLOG_IF(1, status != kSuccess) << __FUNCTION__ << "(" << status << ")";
   DVLOG_IF(3, status == kSuccess) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (buffer.is_null()) {
-    decrypt_cb.Run(static_cast<Decryptor::Status>(status), nullptr);
+    decrypt_cb.Run(status, nullptr);
     return;
   }
 
   scoped_refptr<DecoderBuffer> media_buffer =
       mojo_decoder_buffer_reader_->ReadDecoderBuffer(buffer);
   if (!media_buffer) {
     decrypt_cb.Run(kError, nullptr);
     return;
   }
 
-  decrypt_cb.Run(static_cast<Decryptor::Status>(status), media_buffer);
+  decrypt_cb.Run(status, media_buffer);
 }
 
 void MojoDecryptor::OnAudioDecoded(
     const AudioDecodeCB& audio_decode_cb,
     Status status,
     std::vector<mojom::AudioBufferPtr> audio_buffers) {
   DVLOG_IF(1, status != kSuccess) << __FUNCTION__ << "(" << status << ")";
   DVLOG_IF(3, status == kSuccess) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   Decryptor::AudioFrames audio_frames;
   for (size_t i = 0; i < audio_buffers.size(); ++i)
     audio_frames.push_back(audio_buffers[i].To<scoped_refptr<AudioBuffer>>());
 
-  audio_decode_cb.Run(static_cast<Decryptor::Status>(status), audio_frames);
+  audio_decode_cb.Run(status, audio_frames);
 }
 
 void MojoDecryptor::OnVideoDecoded(const VideoDecodeCB& video_decode_cb,
                                    Status status,
                                    mojom::VideoFramePtr video_frame) {
   DVLOG_IF(1, status != kSuccess) << __FUNCTION__ << "(" << status << ")";
   DVLOG_IF(3, status == kSuccess) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (video_frame.is_null()) {
-    video_decode_cb.Run(static_cast<Decryptor::Status>(status), nullptr);
+    video_decode_cb.Run(status, nullptr);
     return;
   }
 
   scoped_refptr<VideoFrame> frame(video_frame.To<scoped_refptr<VideoFrame>>());
 
   // If using shared memory, ensure that ReleaseSharedBuffer() is called when
   // |frame| is destroyed.
   if (frame->storage_type() == VideoFrame::STORAGE_MOJO_SHARED_BUFFER) {
     MojoSharedBufferVideoFrame* mojo_frame =
         static_cast<MojoSharedBufferVideoFrame*>(frame.get());
     mojo_frame->SetMojoSharedBufferDoneCB(base::Bind(
         &MojoDecryptor::ReleaseSharedBuffer, weak_factory_.GetWeakPtr()));
   }
 
-  video_decode_cb.Run(static_cast<Decryptor::Status>(status), frame);
+  video_decode_cb.Run(status, frame);
 }
 
 void MojoDecryptor::ReleaseSharedBuffer(mojo::ScopedSharedBufferHandle buffer,
                                         size_t buffer_size) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   remote_decryptor_->ReleaseSharedBuffer(std::move(buffer), buffer_size);
 }
 
 }  // namespace media