Prepare MediaDrmBridge to work with MediaCodecPlayer

media/cdm/player_tracker_impl.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/cdm/player_tracker_impl.h"
 
 #include <utility>
 
 #include "base/stl_util.h"
 
 namespace media {
 
 PlayerTrackerImpl::PlayerCallbacks::PlayerCallbacks(
     base::Closure new_key_cb,
     base::Closure cdm_unset_cb)
     : new_key_cb(new_key_cb), cdm_unset_cb(cdm_unset_cb) {
 }
 
 PlayerTrackerImpl::PlayerCallbacks::~PlayerCallbacks() {
 }
 
 PlayerTrackerImpl::PlayerTrackerImpl() : next_registration_id_(1) {}
 
 PlayerTrackerImpl::~PlayerTrackerImpl() {}
 
 int PlayerTrackerImpl::RegisterPlayer(const base::Closure& new_key_cb,
                                       const base::Closure& cdm_unset_cb) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  DVLOG(1) << "PlayerTrackerImpl::RegisterPlayer";
+
+  base::AutoLock lock(lock_);

[qinmin, 2015/09/15 21:10:45]

what is this lock trying to guard against? all these 4 methods here are called
by MediaDrmBridge, they should be on the same thread? no?

[Tima Vaisburd, 2015/09/15 23:48:56]

Yes, the MediaDrmBridge calls them on the same media thread. I added the lock
because I thought I need to implement the MediaDrmProxy methods RegisterPlayer()
and UnregisterPlayer(), they are part of the interface that we return. But it
seems they are never called ?

[Tima Vaisburd, 2015/09/16 01:26:29]

Removed the lock.

+
   int registration_id = next_registration_id_++;
   DCHECK(!ContainsKey(player_callbacks_map_, registration_id));
   player_callbacks_map_.insert(std::make_pair(
       registration_id, PlayerCallbacks(new_key_cb, cdm_unset_cb)));
   return registration_id;
 }
 
 void PlayerTrackerImpl::UnregisterPlayer(int registration_id) {
-  DCHECK(thread_checker_.CalledOnValidThread());
+  base::AutoLock lock(lock_);
+
   DCHECK(ContainsKey(player_callbacks_map_, registration_id))
       << registration_id;
   player_callbacks_map_.erase(registration_id);
 }
 
 void PlayerTrackerImpl::NotifyNewKey() {
+  // Ensure that callbacks are called on the same thread that created this
+  // class.
   DCHECK(thread_checker_.CalledOnValidThread());
+
+  base::AutoLock lock(lock_);
+
   std::map<int, PlayerCallbacks>::iterator iter = player_callbacks_map_.begin();
   for (; iter != player_callbacks_map_.end(); ++iter)
     iter->second.new_key_cb.Run();
 }
 
 void PlayerTrackerImpl::NotifyCdmUnset() {
+  // Ensure that callbacks are called on the same thread that created this
+  // class.
   DCHECK(thread_checker_.CalledOnValidThread());
+
+  base::AutoLock lock(lock_);
+
   std::map<int, PlayerCallbacks>::iterator iter = player_callbacks_map_.begin();
   for (; iter != player_callbacks_map_.end(); ++iter)
     iter->second.cdm_unset_cb.Run();
 }
 
 }  // namespace media