media: Use native Decryptor 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 57 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
 
   mojom::DecoderBufferPtr mojo_buffer =
       mojo_decoder_buffer_writer_->WriteDecoderBuffer(encrypted);
   if (!mojo_buffer) {
     decrypt_cb.Run(kError, nullptr);
     return;
   }
 
   remote_decryptor_->Decrypt(
-      static_cast<mojom::DemuxerStream::Type>(stream_type),
-      std::move(mojo_buffer),
+      stream_type, std::move(mojo_buffer),
       base::Bind(&MojoDecryptor::OnBufferDecrypted, weak_factory_.GetWeakPtr(),
                  decrypt_cb));
 }
 
 void MojoDecryptor::CancelDecrypt(StreamType stream_type) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  remote_decryptor_->CancelDecrypt(
-      static_cast<mojom::DemuxerStream::Type>(stream_type));
+  remote_decryptor_->CancelDecrypt(stream_type);
 }
 
 void MojoDecryptor::InitializeAudioDecoder(const AudioDecoderConfig& config,
                                            const DecoderInitCB& init_cb) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   remote_decryptor_->InitializeAudioDecoder(
       mojom::AudioDecoderConfig::From(config), init_cb);
 }
@@ skipping 42 matching lines @@
   remote_decryptor_->DecryptAndDecodeVideo(
       std::move(mojo_buffer),
       base::Bind(&MojoDecryptor::OnVideoDecoded, weak_factory_.GetWeakPtr(),
                  video_decode_cb));
 }
 
 void MojoDecryptor::ResetDecoder(StreamType stream_type) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  remote_decryptor_->ResetDecoder(
-      static_cast<mojom::DemuxerStream::Type>(stream_type));
+  remote_decryptor_->ResetDecoder(stream_type);
 }
 
 void MojoDecryptor::DeinitializeDecoder(StreamType stream_type) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  remote_decryptor_->DeinitializeDecoder(
-      static_cast<mojom::DemuxerStream::Type>(stream_type));
+  remote_decryptor_->DeinitializeDecoder(stream_type);
 }
 
 void MojoDecryptor::OnKeyAdded() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!new_audio_key_cb_.is_null())
     new_audio_key_cb_.Run();
 
   if (!new_video_key_cb_.is_null())
     new_video_key_cb_.Run();
 }
 
 void MojoDecryptor::OnBufferDecrypted(const DecryptCB& decrypt_cb,
-                                      mojom::Decryptor::Status status,
+                                      Status status,
                                       mojom::DecoderBufferPtr buffer) {
-  DVLOG_IF(1, status != mojom::Decryptor::Status::SUCCESS)
-      << __FUNCTION__ << "(" << status << ")";
-  DVLOG_IF(3, status == mojom::Decryptor::Status::SUCCESS) << __FUNCTION__;
+  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);
     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);
 }
 
 void MojoDecryptor::OnAudioDecoded(
     const AudioDecodeCB& audio_decode_cb,
-    mojom::Decryptor::Status status,
+    Status status,
     std::vector<mojom::AudioBufferPtr> audio_buffers) {
-  DVLOG_IF(1, status != mojom::Decryptor::Status::SUCCESS)
-      << __FUNCTION__ << "(" << status << ")";
-  DVLOG_IF(3, status == mojom::Decryptor::Status::SUCCESS) << __FUNCTION__;
+  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);
 }
 
 void MojoDecryptor::OnVideoDecoded(const VideoDecodeCB& video_decode_cb,
-                                   mojom::Decryptor::Status status,
+                                   Status status,
                                    mojom::VideoFramePtr video_frame) {
-  DVLOG_IF(1, status != mojom::Decryptor::Status::SUCCESS)
-      << __FUNCTION__ << "(" << status << ")";
-  DVLOG_IF(3, status == mojom::Decryptor::Status::SUCCESS) << __FUNCTION__;
+  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);
     return;
   }
 
   scoped_refptr<VideoFrame> frame(video_frame.To<scoped_refptr<VideoFrame>>());
 
   // If using shared memory, ensure that ReleaseSharedBuffer() is called when
@@ skipping 10 matching lines @@
 
 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