media: Add External Clear Key content browser test on Android

media/mojo/clients/mojo_cdm.cc

 // Copyright 2014 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_cdm.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 66 matching lines @@
   remote_cdm_->SetClient(binding_.CreateInterfacePtrAndBind());
 }
 
 MojoCdm::~MojoCdm() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   base::AutoLock auto_lock(lock_);
 
   // Release |decryptor_| on the correct thread. If GetDecryptor() is never
-  // called but |decryptor_ptr_| is not null, it is not bound to any thread and
-  // is safe to be released on the current thread.
+  // called but |decryptor_ptr_info_| is not null, it is not bound to any thread
+  // and is safe to be released on the current thread.
   if (decryptor_task_runner_ &&
       !decryptor_task_runner_->BelongsToCurrentThread() && decryptor_) {
     decryptor_task_runner_->DeleteSoon(FROM_HERE, decryptor_.release());
   }
 }
 
 // Using base::Unretained(this) below is safe because |this| owns |remote_cdm_|,
 // and if |this| is destroyed, |remote_cdm_| will be destroyed as well. Then the
 // error handler can't be invoked and callbacks won't be dispatched.
 
@@ skipping 113 matching lines @@
 
 media::Decryptor* MojoCdm::GetDecryptor() {
   base::AutoLock auto_lock(lock_);
 
   if (!decryptor_task_runner_)
     decryptor_task_runner_ = base::ThreadTaskRunnerHandle::Get();
 
   DCHECK(decryptor_task_runner_->BelongsToCurrentThread());
 
   // Can be called on a different thread.
-  if (decryptor_ptr_) {
+  if (decryptor_ptr_info_.is_valid()) {
     DCHECK(!decryptor_);
-    decryptor_.reset(new MojoDecryptor(std::move(decryptor_ptr_)));
+    mojom::DecryptorPtr decryptor_ptr;
+    decryptor_ptr.Bind(std::move(decryptor_ptr_info_));
+    decryptor_.reset(new MojoDecryptor(std::move(decryptor_ptr)));
   }
 
   return decryptor_.get();
 }
 
 int MojoCdm::GetCdmId() const {
   base::AutoLock auto_lock(lock_);
   // Can be called on a different thread.
   DCHECK_NE(CdmContext::kInvalidCdmId, cdm_id_);
   return cdm_id_;
@@ skipping 64 matching lines @@
 
   if (!result->success) {
     RejectPromise(std::move(pending_init_promise_), std::move(result));
     return;
   }
 
   {
     base::AutoLock auto_lock(lock_);
     DCHECK_NE(CdmContext::kInvalidCdmId, cdm_id);
     cdm_id_ = cdm_id;
-    decryptor_ptr_ = std::move(decryptor);
+    decryptor_ptr_info_ = decryptor.PassInterface();
   }
 
   pending_init_promise_->resolve();
   pending_init_promise_.reset();
 }
 
 void MojoCdm::OnKeyAdded() {
   base::AutoLock auto_lock(lock_);
 
   DCHECK(decryptor_task_runner_);
   DCHECK(decryptor_task_runner_->BelongsToCurrentThread());
   DCHECK(decryptor_);
 
   decryptor_->OnKeyAdded();
 }
 
 }  // namespace media