Add Mojo Decryptor service.

BUG=510153

Review URL: https://codereview.chromium.org/1478883002

Cr-Commit-Position: refs/heads/master@{#362586}

10 files changed, 298 insertions, 34 deletions

diff --git a/media/mojo/interfaces/content_decryption_module.mojom b/media/mojo/interfaces/content_decryption_module.mojom
index 0d7ca30..c55c82a 100644
--- a/media/mojo/interfaces/content_decryption_module.mojom
+++ b/media/mojo/interfaces/content_decryption_module.mojom
@@ -90,9 +90,10 @@ interface ContentDecryptionModule {
   // Initializes the CDM. If initialization failed (e.g. |key_system| or
   // |cdm_config| is not supported), |result.success| will be false and |cdm_id|
   // will be zero. Upon success, |cdm_id| will be non-zero and will later be
-  // used to locate the CDM at the remote side.
+  // used to locate the CDM at the remote side. |decryptor| is the remote
+  // Decryptor.
   Initialize(string key_system, string security_origin, CdmConfig cdm_config)
-      => (CdmPromiseResult result, int32 cdm_id);
+      => (CdmPromiseResult result, int32 cdm_id, Decryptor? decryptor);
 
   // Provides a server certificate to be used to encrypt messages to the
   // license server.
@@ -126,9 +127,6 @@ interface ContentDecryptionModule {
   // Removes stored session data associated with the active session specified by
   // |session_id|.
   RemoveSession(string session_id) => (CdmPromiseResult result);
-
-  // Retrieves the |decryptor| associated with this CDM instance.
-  GetDecryptor(Decryptor&? decryptor);
 };
 
 // Session callbacks. See media/base/media_keys.h for details.
diff --git a/media/mojo/services/BUILD.gn b/media/mojo/services/BUILD.gn
index 23690f80..8275e25 100644
--- a/media/mojo/services/BUILD.gn
+++ b/media/mojo/services/BUILD.gn
@@ -118,6 +118,8 @@ source_set("cdm_service") {
     "mojo_cdm_service.h",
     "mojo_cdm_service_context.cc",
     "mojo_cdm_service_context.h",
+    "mojo_decryptor_service.cc",
+    "mojo_decryptor_service.h",
     "mojo_type_trait.h",
   ]
 
diff --git a/media/mojo/services/media_apptest.cc b/media/mojo/services/media_apptest.cc
index 9c995f6..6d5d0c1 100644
--- a/media/mojo/services/media_apptest.cc
+++ b/media/mojo/services/media_apptest.cc
@@ -12,6 +12,7 @@
 #include "media/base/test_helpers.h"
 #include "media/cdm/key_system_names.h"
 #include "media/mojo/interfaces/content_decryption_module.mojom.h"
+#include "media/mojo/interfaces/decryptor.mojom.h"
 #include "media/mojo/interfaces/renderer.mojom.h"
 #include "media/mojo/interfaces/service_factory.mojom.h"
 #include "media/mojo/services/media_type_converters.h"
@@ -71,7 +72,9 @@ class MediaAppTest : public mojo::test::ApplicationTestBase {
   // MOCK_METHOD* doesn't support move only types. Work around this by having
   // an extra method.
   MOCK_METHOD2(OnCdmInitializedInternal, void(bool result, int cdm_id));
-  void OnCdmInitialized(interfaces::CdmPromiseResultPtr result, int cdm_id) {
+  void OnCdmInitialized(interfaces::CdmPromiseResultPtr result,
+                        int cdm_id,
+                        interfaces::DecryptorPtr decryptor) {
     OnCdmInitializedInternal(result->success, cdm_id);
   }
 
diff --git a/media/mojo/services/mojo_cdm.cc b/media/mojo/services/mojo_cdm.cc
index 00eb28a..e302887 100644
--- a/media/mojo/services/mojo_cdm.cc
+++ b/media/mojo/services/mojo_cdm.cc
@@ -4,11 +4,14 @@
 
 #include "media/mojo/services/mojo_cdm.h"
 
+#include <utility>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "media/base/cdm_context.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/cdm_promise.h"
+#include "media/mojo/interfaces/decryptor.mojom.h"
 #include "media/mojo/services/media_type_converters.h"
 #include "mojo/application/public/cpp/connect.h"
 #include "mojo/application/public/interfaces/service_provider.mojom.h"
@@ -160,6 +163,7 @@ CdmContext* MojoCdm::GetCdmContext() {
 }
 
 media::Decryptor* MojoCdm::GetDecryptor() {
+  // TODO(jrummell): Return a decryptor using |decryptor_ptr_|.
   return nullptr;
 }
 
@@ -224,7 +228,8 @@ void MojoCdm::OnSessionExpirationUpdate(const mojo::String& session_id,
 
 void MojoCdm::OnCdmInitialized(scoped_ptr<CdmInitializedPromise> promise,
                                interfaces::CdmPromiseResultPtr result,
-                               int cdm_id) {
+                               int cdm_id,
+                               interfaces::DecryptorPtr decryptor) {
   DVLOG(2) << __FUNCTION__ << " cdm_id: " << cdm_id;
   if (!result->success) {
     RejectPromise(promise.Pass(), result.Pass());
@@ -233,6 +238,7 @@ void MojoCdm::OnCdmInitialized(scoped_ptr<CdmInitializedPromise> promise,
 
   DCHECK_NE(CdmContext::kInvalidCdmId, cdm_id);
   cdm_id_ = cdm_id;
+  decryptor_ptr_ = std::move(decryptor);
   promise->resolve();
 }
 
diff --git a/media/mojo/services/mojo_cdm.h b/media/mojo/services/mojo_cdm.h
index c84c06b..dc82ed2 100644
--- a/media/mojo/services/mojo_cdm.h
+++ b/media/mojo/services/mojo_cdm.h
@@ -98,11 +98,12 @@ class MojoCdm : public MediaKeys,
                                  double new_expiry_time_sec) final;
 
   // Callback for InitializeCdm.
-  // Note: Cannot use OnPromiseResult() below since we need an extra parameter
-  // |cdm_id|, which isn't needed in CdmInitializedPromise.
+  // Note: Cannot use OnPromiseResult() below since we need an extra parameters
+  // |cdm_id| and |decryptor|, which isn't needed in CdmInitializedPromise.
   void OnCdmInitialized(scoped_ptr<CdmInitializedPromise> promise,
                         interfaces::CdmPromiseResultPtr result,
-                        int cdm_id);
+                        int cdm_id,
+                        interfaces::DecryptorPtr decryptor);
 
   // Callbacks to handle CDM promises.
   // We have to inline this method, since MS VS 2013 compiler fails to compile
@@ -122,6 +123,8 @@ class MojoCdm : public MediaKeys,
   mojo::Binding<ContentDecryptionModuleClient> binding_;
   int cdm_id_;
 
+  interfaces::DecryptorPtr decryptor_ptr_;
+
   // Callbacks for firing session events.
   SessionMessageCB session_message_cb_;
   SessionClosedCB session_closed_cb_;
diff --git a/media/mojo/services/mojo_cdm_promise.cc b/media/mojo/services/mojo_cdm_promise.cc
index bd3862b..6fa1a5a 100644
--- a/media/mojo/services/mojo_cdm_promise.cc
+++ b/media/mojo/services/mojo_cdm_promise.cc
@@ -64,7 +64,6 @@ void MojoCdmPromise<T...>::reject(MediaKeys::Exception exception,
 }
 
 template class MojoCdmPromise<>;
-template class MojoCdmPromise<int>;
 template class MojoCdmPromise<std::string>;
 
 }  // namespace media
diff --git a/media/mojo/services/mojo_cdm_service.cc b/media/mojo/services/mojo_cdm_service.cc
index 3eea807..f41708f 100644
--- a/media/mojo/services/mojo_cdm_service.cc
+++ b/media/mojo/services/mojo_cdm_service.cc
@@ -5,6 +5,7 @@
 #include "media/mojo/services/mojo_cdm_service.h"
 
 #include <map>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ -65,7 +66,6 @@ base::LazyInstance<CdmManager>::Leaky g_cdm_manager = LAZY_INSTANCE_INITIALIZER;
 }  // namespace
 
 using SimpleMojoCdmPromise = MojoCdmPromise<>;
-using CdmIdMojoCdmPromise = MojoCdmPromise<int>;
 using NewSessionMojoCdmPromise = MojoCdmPromise<std::string>;
 
 int MojoCdmService::next_cdm_id_ = CdmContext::kInvalidCdmId + 1;
@@ -103,12 +103,10 @@ void MojoCdmService::SetClient(
   client_ = client.Pass();
 }
 
-void MojoCdmService::Initialize(
-    const mojo::String& key_system,
-    const mojo::String& security_origin,
-    interfaces::CdmConfigPtr cdm_config,
-    const mojo::Callback<void(interfaces::CdmPromiseResultPtr, int32_t)>&
-        callback) {
+void MojoCdmService::Initialize(const mojo::String& key_system,
+                                const mojo::String& security_origin,
+                                interfaces::CdmConfigPtr cdm_config,
+                                const InitializeCallback& callback) {
   DVLOG(1) << __FUNCTION__ << ": " << key_system;
   DCHECK(!cdm_);
 
@@ -120,9 +118,7 @@ void MojoCdmService::Initialize(
       base::Bind(&MojoCdmService::OnLegacySessionError, weak_this),
       base::Bind(&MojoCdmService::OnSessionKeysChange, weak_this),
       base::Bind(&MojoCdmService::OnSessionExpirationUpdate, weak_this),
-      base::Bind(
-          &MojoCdmService::OnCdmCreated, weak_this,
-          base::Passed(make_scoped_ptr(new CdmIdMojoCdmPromise(callback)))));
+      base::Bind(&MojoCdmService::OnCdmCreated, weak_this, callback));
 }
 
 void MojoCdmService::SetServerCertificate(
@@ -184,22 +180,25 @@ void MojoCdmService::RemoveSession(
                       make_scoped_ptr(new SimpleMojoCdmPromise(callback)));
 }
 
-void MojoCdmService::GetDecryptor(
-    mojo::InterfaceRequest<interfaces::Decryptor> decryptor) {
-  NOTIMPLEMENTED();
-}
-
 CdmContext* MojoCdmService::GetCdmContext() {
   return cdm_->GetCdmContext();
 }
 
-void MojoCdmService::OnCdmCreated(scoped_ptr<CdmIdMojoCdmPromise> promise,
+void MojoCdmService::OnCdmCreated(const InitializeCallback& callback,
                                   const scoped_refptr<MediaKeys>& cdm,
                                   const std::string& error_message) {
+  interfaces::CdmPromiseResultPtr cdm_promise_result(
+      interfaces::CdmPromiseResult::New());
+
   // TODO(xhwang): This should not happen when KeySystemInfo is properly
   // populated. See http://crbug.com/469366
   if (!cdm || !context_) {
-    promise->reject(MediaKeys::NOT_SUPPORTED_ERROR, 0, error_message);
+    cdm_promise_result->success = false;
+    cdm_promise_result->exception =
+        interfaces::CDM_EXCEPTION_NOT_SUPPORTED_ERROR;
+    cdm_promise_result->system_code = 0;
+    cdm_promise_result->error_message = error_message;
+    callback.Run(std::move(cdm_promise_result), 0, nullptr);
     return;
   }
 
@@ -209,8 +208,22 @@ void MojoCdmService::OnCdmCreated(scoped_ptr<CdmIdMojoCdmPromise> promise,
   context_->RegisterCdm(cdm_id_, this);
   g_cdm_manager.Get().RegisterCdm(cdm_id_, cdm);
 
+  // If |cdm| has a decryptor, create the MojoDecryptorService
+  // and pass the connection back to the client.
+  interfaces::DecryptorPtr decryptor_service;
+  CdmContext* const cdm_context = GetCdmContext();
+  if (cdm_context && cdm_context->GetDecryptor()) {
+    // MojoDecryptorService takes a reference to the CDM, but it is still owned
+    // by |this|.
+    decryptor_.reset(new MojoDecryptorService(
+        cdm_, GetProxy(&decryptor_service),
+        base::Bind(&MojoCdmService::OnDecryptorConnectionError, weak_this_)));
+  }
+
   DVLOG(1) << __FUNCTION__ << ": CDM successfully created with ID " << cdm_id_;
-  promise->resolve(cdm_id_);
+  cdm_promise_result->success = true;
+  callback.Run(std::move(cdm_promise_result), cdm_id_,
+               std::move(decryptor_service));
 }
 
 void MojoCdmService::OnSessionMessage(const std::string& session_id,
@@ -258,4 +271,12 @@ void MojoCdmService::OnLegacySessionError(const std::string& session_id,
       error_message);
 }
 
+void MojoCdmService::OnDecryptorConnectionError() {
+  DVLOG(2) << __FUNCTION__;
+
+  // MojoDecryptorService has lost connectivity to it's client, so it can be
+  // freed.
+  decryptor_.reset();
+}
+
 }  // namespace media
diff --git a/media/mojo/services/mojo_cdm_service.h b/media/mojo/services/mojo_cdm_service.h
index 7df3df6..d41ad2f 100644
--- a/media/mojo/services/mojo_cdm_service.h
+++ b/media/mojo/services/mojo_cdm_service.h
@@ -14,6 +14,7 @@
 #include "media/mojo/interfaces/content_decryption_module.mojom.h"
 #include "media/mojo/services/mojo_cdm_promise.h"
 #include "media/mojo/services/mojo_cdm_service_context.h"
+#include "media/mojo/services/mojo_decryptor_service.h"
 #include "mojo/application/public/interfaces/service_provider.mojom.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 
@@ -49,8 +50,7 @@ class MojoCdmService : public interfaces::ContentDecryptionModule {
   void Initialize(const mojo::String& key_system,
                   const mojo::String& security_origin,
                   interfaces::CdmConfigPtr cdm_config,
-                  const mojo::Callback<void(interfaces::CdmPromiseResultPtr,
-                                            int32_t)>& callback) final;
+                  const InitializeCallback& callback) final;
   void SetServerCertificate(
       mojo::Array<uint8_t> certificate_data,
       const mojo::Callback<void(interfaces::CdmPromiseResultPtr)>& callback)
@@ -78,15 +78,13 @@ class MojoCdmService : public interfaces::ContentDecryptionModule {
       const mojo::String& session_id,
       const mojo::Callback<void(interfaces::CdmPromiseResultPtr)>& callback)
       final;
-  void GetDecryptor(
-      mojo::InterfaceRequest<interfaces::Decryptor> decryptor) final;
 
   // Get CdmContext to be used by the media pipeline.
   CdmContext* GetCdmContext();
 
  private:
   // Callback for CdmFactory::Create().
-  void OnCdmCreated(scoped_ptr<MojoCdmPromise<int>> promise,
+  void OnCdmCreated(const InitializeCallback& callback,
                     const scoped_refptr<MediaKeys>& cdm,
                     const std::string& error_message);
 
@@ -106,6 +104,9 @@ class MojoCdmService : public interfaces::ContentDecryptionModule {
                             uint32_t system_code,
                             const std::string& error_message);
 
+  // Callback for when |decryptor_| loses connectivity.
+  void OnDecryptorConnectionError();
+
   // CDM ID to be assigned to the next successfully initialized CDM. This ID is
   // unique per process. It will be used to locate the CDM by the media players
   // living in the same process.
@@ -118,6 +119,8 @@ class MojoCdmService : public interfaces::ContentDecryptionModule {
   CdmFactory* cdm_factory_;
   scoped_refptr<MediaKeys> cdm_;
 
+  scoped_ptr<MojoDecryptorService> decryptor_;
+
   // Set to a valid CDM ID if the |cdm_| is successfully created.
   int cdm_id_;
 
diff --git a/media/mojo/services/mojo_decryptor_service.cc b/media/mojo/services/mojo_decryptor_service.cc
new file mode 100644
index 0000000..774684a
--- /dev/null
+++ b/media/mojo/services/mojo_decryptor_service.cc
@@ -0,0 +1,139 @@
+// 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 "base/bind.h"
+#include "media/base/audio_decoder_config.h"
+#include "media/base/cdm_context.h"
+#include "media/base/decoder_buffer.h"
+#include "media/base/decryptor.h"
+#include "media/base/media_keys.h"
+#include "media/base/video_decoder_config.h"
+#include "media/mojo/interfaces/demuxer_stream.mojom.h"
+#include "media/mojo/services/media_type_converters.h"
+
+namespace media {
+
+MojoDecryptorService::MojoDecryptorService(
+    const scoped_refptr<MediaKeys>& cdm,
+    mojo::InterfaceRequest<interfaces::Decryptor> request,
+    const mojo::Closure& error_handler)
+    : binding_(this, request.Pass()), cdm_(cdm), weak_factory_(this) {
+  decryptor_ = cdm->GetCdmContext()->GetDecryptor();
+  DCHECK(decryptor_);
+  weak_this_ = weak_factory_.GetWeakPtr();
+  binding_.set_connection_error_handler(error_handler);
+}
+
+MojoDecryptorService::~MojoDecryptorService() {}
+
+void MojoDecryptorService::Decrypt(interfaces::DemuxerStream::Type stream_type,
+                                   interfaces::DecoderBufferPtr encrypted,
+                                   const DecryptCallback& callback) {
+  decryptor_->Decrypt(
+      static_cast<media::Decryptor::StreamType>(stream_type),
+      encrypted.To<scoped_refptr<DecoderBuffer>>(),
+      base::Bind(&MojoDecryptorService::OnDecryptDone, weak_this_, callback));
+}
+
+void MojoDecryptorService::CancelDecrypt(
+    interfaces::DemuxerStream::Type stream_type) {
+  decryptor_->CancelDecrypt(
+      static_cast<media::Decryptor::StreamType>(stream_type));
+}
+
+void MojoDecryptorService::InitializeAudioDecoder(
+    interfaces::AudioDecoderConfigPtr config,
+    const InitializeAudioDecoderCallback& callback) {
+  decryptor_->InitializeAudioDecoder(
+      config.To<AudioDecoderConfig>(),
+      base::Bind(&MojoDecryptorService::OnAudioDecoderInitialized, weak_this_,
+                 callback));
+}
+
+void MojoDecryptorService::InitializeVideoDecoder(
+    interfaces::VideoDecoderConfigPtr config,
+    const InitializeVideoDecoderCallback& callback) {
+  decryptor_->InitializeVideoDecoder(
+      config.To<VideoDecoderConfig>(),
+      base::Bind(&MojoDecryptorService::OnVideoDecoderInitialized, weak_this_,
+                 callback));
+}
+
+void MojoDecryptorService::DecryptAndDecodeAudio(
+    interfaces::DecoderBufferPtr encrypted,
+    const DecryptAndDecodeAudioCallback& callback) {
+  decryptor_->DecryptAndDecodeAudio(
+      encrypted.To<scoped_refptr<DecoderBuffer>>(),
+      base::Bind(&MojoDecryptorService::OnAudioDecoded, weak_this_, callback));
+}
+
+void MojoDecryptorService::DecryptAndDecodeVideo(
+    interfaces::DecoderBufferPtr encrypted,
+    const DecryptAndDecodeVideoCallback& callback) {
+  decryptor_->DecryptAndDecodeVideo(
+      encrypted.To<scoped_refptr<DecoderBuffer>>(),
+      base::Bind(&MojoDecryptorService::OnVideoDecoded, weak_this_, callback));
+}
+
+void MojoDecryptorService::ResetDecoder(
+    interfaces::DemuxerStream::Type stream_type) {
+  decryptor_->ResetDecoder(
+      static_cast<media::Decryptor::StreamType>(stream_type));
+}
+
+void MojoDecryptorService::DeinitializeDecoder(
+    interfaces::DemuxerStream::Type stream_type) {
+  decryptor_->DeinitializeDecoder(
+      static_cast<media::Decryptor::StreamType>(stream_type));
+}
+
+void MojoDecryptorService::OnDecryptDone(
+    const DecryptCallback& callback,
+    media::Decryptor::Status status,
+    const scoped_refptr<DecoderBuffer>& buffer) {
+  DVLOG(1) << __FUNCTION__ << "(" << status << ")";
+  callback.Run(static_cast<Decryptor::Status>(status),
+               interfaces::DecoderBuffer::From(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,
+    const media::Decryptor::AudioFrames& frames) {
+  DVLOG(1) << __FUNCTION__ << "(" << status << ")";
+
+  mojo::Array<interfaces::AudioBufferPtr> audio_buffers;
+  for (const auto& frame : frames)
+    audio_buffers.push_back(interfaces::AudioBuffer::From(frame).Pass());
+
+  callback.Run(static_cast<Decryptor::Status>(status), audio_buffers.Pass());
+}
+
+void MojoDecryptorService::OnVideoDecoded(
+    const DecryptAndDecodeVideoCallback& callback,
+    media::Decryptor::Status status,
+    const scoped_refptr<VideoFrame>& frame) {
+  DVLOG(1) << __FUNCTION__ << "(" << status << ")";
+
+  callback.Run(static_cast<Decryptor::Status>(status),
+               interfaces::VideoFrame::From(frame).Pass());
+}
+
+}  // namespace media
diff --git a/media/mojo/services/mojo_decryptor_service.h b/media/mojo/services/mojo_decryptor_service.h
new file mode 100644
index 0000000..fe00699e
--- /dev/null
+++ b/media/mojo/services/mojo_decryptor_service.h
@@ -0,0 +1,90 @@
+// 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.
+
+#ifndef MEDIA_MOJO_SERVICES_MOJO_DECRYPTOR_SERVICE_H_
+#define MEDIA_MOJO_SERVICES_MOJO_DECRYPTOR_SERVICE_H_
+
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
+#include "media/base/decryptor.h"
+#include "media/mojo/interfaces/decryptor.mojom.h"
+#include "mojo/public/cpp/bindings/binding.h"
+#include "mojo/public/cpp/bindings/callback.h"
+
+namespace media {
+
+class DecoderBuffer;
+class MediaKeys;
+
+// A interfaces::Decryptor implementation. This object is owned by the creator,
+// and uses a weak binding across the mojo interface.
+class MojoDecryptorService : public interfaces::Decryptor {
+ public:
+  // Constructs a MojoDecryptorService and binds it to the |request|. Keeps a
+  // copy of |cdm| to prevent it from being deleted as long as it is needed.
+  // |error_handler| will be called if a connection error occurs.
+  MojoDecryptorService(const scoped_refptr<MediaKeys>& cdm,
+                       mojo::InterfaceRequest<interfaces::Decryptor> request,
+                       const mojo::Closure& error_handler);
+
+  ~MojoDecryptorService() final;
+
+  // interfaces::Decryptor implementation.
+  void Decrypt(interfaces::DemuxerStream::Type stream_type,
+               interfaces::DecoderBufferPtr encrypted,
+               const DecryptCallback& callback) final;
+  void CancelDecrypt(interfaces::DemuxerStream::Type stream_type) final;
+  void InitializeAudioDecoder(
+      interfaces::AudioDecoderConfigPtr config,
+      const InitializeAudioDecoderCallback& callback) final;
+  void InitializeVideoDecoder(
+      interfaces::VideoDecoderConfigPtr config,
+      const InitializeVideoDecoderCallback& callback) final;
+  void DecryptAndDecodeAudio(
+      interfaces::DecoderBufferPtr encrypted,
+      const DecryptAndDecodeAudioCallback& callback) final;
+  void DecryptAndDecodeVideo(
+      interfaces::DecoderBufferPtr encrypted,
+      const DecryptAndDecodeVideoCallback& callback) final;
+  void ResetDecoder(interfaces::DemuxerStream::Type stream_type) final;
+  void DeinitializeDecoder(interfaces::DemuxerStream::Type stream_type) final;
+
+ private:
+  // Callback executed once Decrypt() is done.
+  void OnDecryptDone(const DecryptCallback& callback,
+                     media::Decryptor::Status status,
+                     const scoped_refptr<DecoderBuffer>& buffer);
+
+  // Callbacks executed once decoder initialized.
+  void OnAudioDecoderInitialized(const InitializeAudioDecoderCallback& callback,
+                                 bool success);
+  void OnVideoDecoderInitialized(const InitializeVideoDecoderCallback& callback,
+                                 bool success);
+
+  // Callbacks executed when DecryptAndDecode are done.
+  void OnAudioDecoded(const DecryptAndDecodeAudioCallback& callback,
+                      media::Decryptor::Status status,
+                      const media::Decryptor::AudioFrames& frames);
+  void OnVideoDecoded(const DecryptAndDecodeVideoCallback& callback,
+                      media::Decryptor::Status status,
+                      const scoped_refptr<VideoFrame>& frame);
+
+  // A weak binding is used to connect to the MojoDecryptor.
+  mojo::Binding<interfaces::Decryptor> binding_;
+
+  // Keep ownership of |cdm_| while it is being used. |decryptor_| is the actual
+  // Decryptor referenced by |cdm_|.
+  scoped_refptr<MediaKeys> cdm_;
+  media::Decryptor* decryptor_;
+
+  base::WeakPtr<MojoDecryptorService> weak_this_;
+  base::WeakPtrFactory<MojoDecryptorService> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(MojoDecryptorService);
+};
+
+}  // namespace media
+
+#endif  // MEDIA_MOJO_SERVICES_MOJO_DECRYPTOR_SERVICE_H_