Add Promises for EME (Chromium side)

content/browser/media/android/browser_media_player_manager.cc

 // Copyright 2013 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 "content/browser/media/android/browser_media_player_manager.h"
 
 #include "base/android/scoped_java_ref.h"
 #include "base/command_line.h"
 #include "base/stl_util.h"
 #include "content/browser/android/content_view_core_impl.h"
@@ skipping 13 matching lines @@
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "media/base/android/media_player_bridge.h"
 #include "media/base/android/media_source_player.h"
 #include "media/base/cdm_factory.h"
 #include "media/base/media_switches.h"
 
-using media::MediaKeys;
+using media::MediaDrmBridge;
 using media::MediaPlayerAndroid;
 using media::MediaPlayerBridge;
 using media::MediaPlayerManager;
 using media::MediaSourcePlayer;
 
 namespace content {
 
 // Threshold on the number of media players per renderer before we start
 // attempting to release inactive media players.
 const int kMediaPlayerThreshold = 1;
@@ skipping 265 matching lines @@
 
 MediaPlayerAndroid* BrowserMediaPlayerManager::GetPlayer(int player_id) {
   for (ScopedVector<MediaPlayerAndroid>::iterator it = players_.begin();
       it != players_.end(); ++it) {
     if ((*it)->player_id() == player_id)
       return *it;
   }
   return NULL;
 }
 
-MediaKeys* BrowserMediaPlayerManager::GetCdm(int cdm_id) {
+MediaDrmBridge* BrowserMediaPlayerManager::GetCdm(int cdm_id) {
   CdmMap::const_iterator iter = cdm_map_.find(cdm_id);
   return (iter == cdm_map_.end()) ? NULL : iter->second;
 }
 
 void BrowserMediaPlayerManager::DestroyAllMediaPlayers() {
   players_.clear();
   STLDeleteValues(&cdm_map_);
   if (fullscreen_player_id_ != -1) {
     video_view_.reset();
     fullscreen_player_id_ = -1;
@@ skipping 274 matching lines @@
       NOTREACHED();
       return;
   }
 
   if (CommandLine::ForCurrentProcess()
       ->HasSwitch(switches::kDisableInfobarForProtectedMediaIdentifier)) {
     CreateSessionIfPermitted(cdm_id, session_id, mime_type, init_data, true);
     return;
   }
 
-  MediaKeys* cdm = GetCdm(cdm_id);
+  MediaDrmBridge* cdm = GetCdm(cdm_id);
   if (!cdm) {
     DLOG(WARNING) << "No CDM for ID " << cdm_id << " found";
     OnSessionError(cdm_id, session_id, media::MediaKeys::kUnknownError, 0);
     return;
   }
 
   BrowserContext* context =
       web_contents()->GetRenderProcessHost()->GetBrowserContext();
 
   std::map<int, GURL>::const_iterator iter =
@@ skipping 15 matching lines @@
                  cdm_id,
                  session_id,
                  mime_type,
                  init_data));
 }
 
 void BrowserMediaPlayerManager::OnUpdateSession(
     int cdm_id,
     uint32 session_id,
     const std::vector<uint8>& response) {
-  MediaKeys* cdm = GetCdm(cdm_id);
+  MediaDrmBridge* cdm = GetCdm(cdm_id);
   if (!cdm) {
     DLOG(WARNING) << "No CDM for ID " << cdm_id << " found";
     OnSessionError(cdm_id, session_id, media::MediaKeys::kUnknownError, 0);
     return;
   }
 
   if (response.size() > kMaxSessionResponseLength) {
     LOG(WARNING) << "Response for ID " << cdm_id
                  << " is too long: " << response.size();
     OnSessionError(cdm_id, session_id, media::MediaKeys::kUnknownError, 0);
     return;
   }
 
   cdm->UpdateSession(session_id, &response[0], response.size());
 
   CdmToPlayerMap::const_iterator iter = cdm_to_player_map_.find(cdm_id);
   if (iter == cdm_to_player_map_.end())
     return;
 
   int player_id = iter->second;
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (player)
     player->OnKeyAdded();
 }
 
 void BrowserMediaPlayerManager::OnReleaseSession(int cdm_id,
                                                  uint32 session_id) {
-  MediaKeys* cdm = GetCdm(cdm_id);
+  MediaDrmBridge* cdm = GetCdm(cdm_id);
   if (!cdm) {
     DLOG(WARNING) << "No CDM for ID " << cdm_id << " found";
     OnSessionError(cdm_id, session_id, media::MediaKeys::kUnknownError, 0);
     return;
   }
 
   cdm->ReleaseSession(session_id);
 }
 
 void BrowserMediaPlayerManager::OnDestroyCdm(int cdm_id) {
-  MediaKeys* cdm = GetCdm(cdm_id);
+  MediaDrmBridge* cdm = GetCdm(cdm_id);
   if (!cdm)
     return;
 
   CancelAllPendingSessionCreations(cdm_id);
   RemoveCdm(cdm_id);
 }
 
 void BrowserMediaPlayerManager::CancelAllPendingSessionCreations(int cdm_id) {
   BrowserContext* context =
       web_contents()->GetRenderProcessHost()->GetBrowserContext();
@@ skipping 40 matching lines @@
   return scoped_ptr<media::MediaPlayerAndroid>(previous_player);
 }
 
 void BrowserMediaPlayerManager::AddCdm(int cdm_id,
                                        const std::string& key_system,
                                        const GURL& security_origin) {
   DCHECK(!GetCdm(cdm_id));
   base::WeakPtr<BrowserMediaPlayerManager> weak_this =
       weak_ptr_factory_.GetWeakPtr();
 
-  scoped_ptr<MediaKeys> cdm(media::CreateBrowserCdm(
+  scoped_ptr<MediaDrmBridge> cdm(media::CreateBrowserCdm(
       key_system,
       base::Bind(
           &BrowserMediaPlayerManager::OnSessionCreated, weak_this, cdm_id),
       base::Bind(
           &BrowserMediaPlayerManager::OnSessionMessage, weak_this, cdm_id),
       base::Bind(
           &BrowserMediaPlayerManager::OnSessionReady, weak_this, cdm_id),
       base::Bind(
           &BrowserMediaPlayerManager::OnSessionClosed, weak_this, cdm_id),
       base::Bind(
@@ skipping 19 matching lines @@
   if (iter != cdm_map_.end()) {
     delete iter->second;
     cdm_map_.erase(iter);
   }
   cdm_to_player_map_.erase(cdm_id);
   cdm_security_origin_map_.erase(cdm_id);
 }
 
 void BrowserMediaPlayerManager::OnSetCdm(int player_id, int cdm_id) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
-  MediaKeys* cdm = GetCdm(cdm_id);
+  MediaDrmBridge* cdm = GetCdm(cdm_id);
   if (!cdm || !player) {
     DVLOG(1) << "Cannot set CDM on the specified player.";
     return;
   }
 
   // TODO(qinmin): add the logic to decide whether we should create the
   // fullscreen surface for EME lv1.
   player->SetCdm(cdm);
   // Do now support setting one CDM on multiple players.
 
@@ skipping 17 matching lines @@
     int cdm_id,
     uint32 session_id,
     const std::string& content_type,
     const std::vector<uint8>& init_data,
     bool permitted) {
   if (!permitted) {
     OnSessionError(cdm_id, session_id, media::MediaKeys::kUnknownError, 0);
     return;
   }
 
-  MediaKeys* cdm = GetCdm(cdm_id);
+  MediaDrmBridge* cdm = GetCdm(cdm_id);
   if (!cdm) {
     DLOG(WARNING) << "No CDM for ID: " << cdm_id << " found";
     OnSessionError(cdm_id, session_id, media::MediaKeys::kUnknownError, 0);
     return;
   }
 
   // This could fail, in which case a SessionError will be fired.
   cdm->CreateSession(session_id, content_type, &init_data[0], init_data.size());
 }
 
@@ skipping 34 matching lines @@
 #if defined(VIDEO_HOLE)
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (player && player->IsSurfaceInUse())
     return;
   if (external_video_surface_container_)
     external_video_surface_container_->ReleaseExternalVideoSurface(player_id);
 #endif  // defined(VIDEO_HOLE)
 }
 
 }  // namespace content