media: Use native Decryptor enum types in media mojo interfaces

media/mojo/services/mojo_decryptor_service.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/services/mojo_decryptor_service.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/numerics/safe_conversions.h"
@@ skipping 27 matching lines @@
 
 void MojoDecryptorService::Initialize(
     mojo::ScopedDataPipeConsumerHandle receive_pipe,
     mojo::ScopedDataPipeProducerHandle transmit_pipe) {
   mojo_decoder_buffer_writer_.reset(
       new MojoDecoderBufferWriter(std::move(transmit_pipe)));
   mojo_decoder_buffer_reader_.reset(
       new MojoDecoderBufferReader(std::move(receive_pipe)));
 }
 
-void MojoDecryptorService::Decrypt(mojom::DemuxerStream::Type stream_type,
+void MojoDecryptorService::Decrypt(StreamType stream_type,
                                    mojom::DecoderBufferPtr encrypted,
                                    const DecryptCallback& callback) {
   DVLOG(3) << __FUNCTION__;
 
   scoped_refptr<DecoderBuffer> media_buffer =
       mojo_decoder_buffer_reader_->ReadDecoderBuffer(encrypted);
   if (!media_buffer) {
-    callback.Run(Status::DECRYPTION_ERROR, nullptr);
+    callback.Run(Status::kError, nullptr);
     return;
   }
 
   decryptor_->Decrypt(
-      static_cast<media::Decryptor::StreamType>(stream_type),
-      std::move(media_buffer),
+      stream_type, std::move(media_buffer),
       base::Bind(&MojoDecryptorService::OnDecryptDone, weak_this_, callback));
 }
 
-void MojoDecryptorService::CancelDecrypt(
-    mojom::DemuxerStream::Type stream_type) {
+void MojoDecryptorService::CancelDecrypt(StreamType stream_type) {
   DVLOG(1) << __FUNCTION__;
-  decryptor_->CancelDecrypt(
-      static_cast<media::Decryptor::StreamType>(stream_type));
+  decryptor_->CancelDecrypt(stream_type);
 }
 
 void MojoDecryptorService::InitializeAudioDecoder(
     mojom::AudioDecoderConfigPtr config,
     const InitializeAudioDecoderCallback& callback) {
   DVLOG(1) << __FUNCTION__;
   decryptor_->InitializeAudioDecoder(
       config.To<AudioDecoderConfig>(),
       base::Bind(&MojoDecryptorService::OnAudioDecoderInitialized, weak_this_,
                  callback));
@@ skipping 10 matching lines @@
 }
 
 void MojoDecryptorService::DecryptAndDecodeAudio(
     mojom::DecoderBufferPtr encrypted,
     const DecryptAndDecodeAudioCallback& callback) {
   DVLOG(3) << __FUNCTION__;
 
   scoped_refptr<DecoderBuffer> media_buffer =
       mojo_decoder_buffer_reader_->ReadDecoderBuffer(encrypted);
   if (!media_buffer) {
-    callback.Run(Status::DECRYPTION_ERROR,
-                 std::vector<mojom::AudioBufferPtr>());
+    callback.Run(Status::kError, std::vector<mojom::AudioBufferPtr>());
     return;
   }
 
   decryptor_->DecryptAndDecodeAudio(
       std::move(media_buffer),
       base::Bind(&MojoDecryptorService::OnAudioDecoded, weak_this_, callback));
 }
 
 void MojoDecryptorService::DecryptAndDecodeVideo(
     mojom::DecoderBufferPtr encrypted,
     const DecryptAndDecodeVideoCallback& callback) {
   DVLOG(3) << __FUNCTION__;
 
   scoped_refptr<DecoderBuffer> media_buffer =
       mojo_decoder_buffer_reader_->ReadDecoderBuffer(encrypted);
   if (!media_buffer) {
-    callback.Run(Status::DECRYPTION_ERROR, nullptr);
+    callback.Run(Status::kError, nullptr);
     return;
   }
 
   decryptor_->DecryptAndDecodeVideo(
       std::move(media_buffer),
       base::Bind(&MojoDecryptorService::OnVideoDecoded, weak_this_, callback));
 }
 
-void MojoDecryptorService::ResetDecoder(
-    mojom::DemuxerStream::Type stream_type) {
+void MojoDecryptorService::ResetDecoder(StreamType stream_type) {
   DVLOG(1) << __FUNCTION__;
-  decryptor_->ResetDecoder(
-      static_cast<media::Decryptor::StreamType>(stream_type));
+  decryptor_->ResetDecoder(stream_type);
 }
 
-void MojoDecryptorService::DeinitializeDecoder(
-    mojom::DemuxerStream::Type stream_type) {
+void MojoDecryptorService::DeinitializeDecoder(StreamType stream_type) {
   DVLOG(1) << __FUNCTION__;
-  decryptor_->DeinitializeDecoder(
-      static_cast<media::Decryptor::StreamType>(stream_type));
+  decryptor_->DeinitializeDecoder(stream_type);
 }
 
 void MojoDecryptorService::ReleaseSharedBuffer(
     mojo::ScopedSharedBufferHandle buffer,
     uint64_t buffer_size) {
   in_use_video_frames_.erase(buffer.get().value());
 }
 
 void MojoDecryptorService::OnDecryptDone(
     const DecryptCallback& callback,
-    media::Decryptor::Status status,
+    Status status,
     const scoped_refptr<DecoderBuffer>& buffer) {
-  DVLOG_IF(1, status != media::Decryptor::kSuccess) << __FUNCTION__ << "("
-                                                    << status << ")";
-  DVLOG_IF(3, status == media::Decryptor::kSuccess) << __FUNCTION__;
+  DVLOG_IF(1, status != Status::kSuccess) << __FUNCTION__ << "(" << status
+                                          << ")";
+  DVLOG_IF(3, status == Status::kSuccess) << __FUNCTION__;
 
   if (!buffer) {
-    DCHECK_NE(status, media::Decryptor::kSuccess);
-    callback.Run(static_cast<Decryptor::Status>(status), nullptr);
+    DCHECK_NE(status, Status::kSuccess);
+    callback.Run(status, nullptr);
     return;
   }
 
   mojom::DecoderBufferPtr mojo_buffer =
       mojo_decoder_buffer_writer_->WriteDecoderBuffer(buffer);
   if (!mojo_buffer) {
-    callback.Run(Status::DECRYPTION_ERROR, nullptr);
+    callback.Run(Status::kError, nullptr);
     return;
   }
 
-  callback.Run(static_cast<Decryptor::Status>(status), std::move(mojo_buffer));
+  callback.Run(status, std::move(mojo_buffer));
 }
 
 void MojoDecryptorService::OnAudioDecoderInitialized(
     const InitializeAudioDecoderCallback& callback,
     bool success) {
   DVLOG(1) << __FUNCTION__ << "(" << success << ")";
   callback.Run(success);
 }
 
 void MojoDecryptorService::OnVideoDecoderInitialized(
     const InitializeVideoDecoderCallback& callback,
     bool success) {
   DVLOG(1) << __FUNCTION__ << "(" << success << ")";
   callback.Run(success);
 }
 
 void MojoDecryptorService::OnAudioDecoded(
     const DecryptAndDecodeAudioCallback& callback,
-    media::Decryptor::Status status,
+    Status status,
     const media::Decryptor::AudioFrames& frames) {
-  DVLOG_IF(1, status != media::Decryptor::kSuccess) << __FUNCTION__ << "("
-                                                    << status << ")";
-  DVLOG_IF(3, status == media::Decryptor::kSuccess) << __FUNCTION__;
+  DVLOG_IF(1, status != Status::kSuccess) << __FUNCTION__ << "(" << status
+                                          << ")";
+  DVLOG_IF(3, status == Status::kSuccess) << __FUNCTION__;
 
   std::vector<mojom::AudioBufferPtr> audio_buffers;
   for (const auto& frame : frames)
     audio_buffers.push_back(mojom::AudioBuffer::From(frame));
 
-  callback.Run(static_cast<Decryptor::Status>(status),
-               std::move(audio_buffers));
+  callback.Run(status, std::move(audio_buffers));
 }
 
 void MojoDecryptorService::OnVideoDecoded(
     const DecryptAndDecodeVideoCallback& callback,
-    media::Decryptor::Status status,
+    Status status,
     const scoped_refptr<VideoFrame>& frame) {
-  DVLOG_IF(1, status != media::Decryptor::kSuccess) << __FUNCTION__ << "("
-                                                    << status << ")";
-  DVLOG_IF(3, status == media::Decryptor::kSuccess) << __FUNCTION__;
+  DVLOG_IF(1, status != Status::kSuccess) << __FUNCTION__ << "(" << status
+                                          << ")";
+  DVLOG_IF(3, status == Status::kSuccess) << __FUNCTION__;
 
   if (!frame) {
-    DCHECK_NE(status, media::Decryptor::kSuccess);
-    callback.Run(static_cast<Decryptor::Status>(status), nullptr);
+    DCHECK_NE(status, Status::kSuccess);
+    callback.Run(status, nullptr);
     return;
   }
 
   // If |frame| has shared memory that will be passed back, keep a reference
   // to it until the other side is done with the memory.
   if (frame->storage_type() == VideoFrame::STORAGE_MOJO_SHARED_BUFFER) {
     MojoSharedBufferVideoFrame* mojo_frame =
         static_cast<MojoSharedBufferVideoFrame*>(frame.get());
     in_use_video_frames_.insert(
         std::make_pair(mojo_frame->Handle().value(), frame));
   }
 
-  callback.Run(static_cast<Decryptor::Status>(status),
-               mojom::VideoFrame::From(frame));
+  callback.Run(status, mojom::VideoFrame::From(frame));
 }
 
 }  // namespace media