root/content/renderer/media/android/proxy_media_keys.cc

DEFINITIONS

1. session_error_cb_
2. InitializeCdm
3. CreateSession
4. LoadSession
5. UpdateSession
6. ReleaseSession
7. OnSessionCreated
8. OnSessionMessage
9. OnSessionReady
10. OnSessionClosed
11. OnSessionError
12. GetCdmId

// 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/renderer/media/android/proxy_media_keys.h"

#include <vector>

#include "base/basictypes.h"
#include "base/logging.h"
#include "content/renderer/media/android/renderer_media_player_manager.h"
#include "content/renderer/media/crypto/key_systems.h"

namespace content {

int ProxyMediaKeys::next_cdm_id_ =
    RendererMediaPlayerManager::kInvalidCdmId + 1;

ProxyMediaKeys::ProxyMediaKeys(
    RendererMediaPlayerManager* manager,
    const media::SessionCreatedCB& session_created_cb,
    const media::SessionMessageCB& session_message_cb,
    const media::SessionReadyCB& session_ready_cb,
    const media::SessionClosedCB& session_closed_cb,
    const media::SessionErrorCB& session_error_cb)
    : manager_(manager),
      cdm_id_(next_cdm_id_++),
      session_created_cb_(session_created_cb),
      session_message_cb_(session_message_cb),
      session_ready_cb_(session_ready_cb),
      session_closed_cb_(session_closed_cb),
      session_error_cb_(session_error_cb) {
  DCHECK(manager_);
}

ProxyMediaKeys::~ProxyMediaKeys() {
  manager_->DestroyCdm(cdm_id_);
}

void ProxyMediaKeys::InitializeCdm(const std::string& key_system,
                                   const GURL& security_origin) {
  manager_->InitializeCdm(cdm_id_, this, key_system, security_origin);
}

bool ProxyMediaKeys::CreateSession(uint32 session_id,
                                   const std::string& content_type,
                                   const uint8* init_data,
                                   int init_data_length) {
  // TODO(xhwang): Move these checks up to blink and DCHECK here.
  // See http://crbug.com/342510
  CdmHostMsg_CreateSession_ContentType session_type;
  if (content_type == "audio/mp4" || content_type == "video/mp4") {
    session_type = CREATE_SESSION_TYPE_MP4;
  } else if (content_type == "audio/webm" || content_type == "video/webm") {
    session_type = CREATE_SESSION_TYPE_WEBM;
  } else {
    DLOG(ERROR) << "Unsupported EME CreateSession content type of "
                << content_type;
    return false;
  }

  manager_->CreateSession(
      cdm_id_,
      session_id,
      session_type,
      std::vector<uint8>(init_data, init_data + init_data_length));
  return true;
}

void ProxyMediaKeys::LoadSession(uint32 session_id,
                                 const std::string& web_session_id) {
  // TODO(xhwang): Check key system and platform support for LoadSession in
  // blink and add NOTREACHED() here.
  DLOG(ERROR) << "ProxyMediaKeys doesn't support session loading.";
  OnSessionError(session_id, media::MediaKeys::kUnknownError, 0);
}

void ProxyMediaKeys::UpdateSession(uint32 session_id,
                                   const uint8* response,
                                   int response_length) {
  manager_->UpdateSession(
      cdm_id_,
      session_id,
      std::vector<uint8>(response, response + response_length));
}

void ProxyMediaKeys::ReleaseSession(uint32 session_id) {
  manager_->ReleaseSession(cdm_id_, session_id);
}

void ProxyMediaKeys::OnSessionCreated(uint32 session_id,
                                      const std::string& web_session_id) {
  session_created_cb_.Run(session_id, web_session_id);
}

void ProxyMediaKeys::OnSessionMessage(uint32 session_id,
                                      const std::vector<uint8>& message,
                                      const std::string& destination_url) {
  session_message_cb_.Run(session_id, message, destination_url);
}

void ProxyMediaKeys::OnSessionReady(uint32 session_id) {
  session_ready_cb_.Run(session_id);
}

void ProxyMediaKeys::OnSessionClosed(uint32 session_id) {
  session_closed_cb_.Run(session_id);
}

void ProxyMediaKeys::OnSessionError(uint32 session_id,
                                    media::MediaKeys::KeyError error_code,
                                    uint32 system_code) {
  session_error_cb_.Run(session_id, error_code, system_code);
}

int ProxyMediaKeys::GetCdmId() const {
  return cdm_id_;
}

}  // namespace content