Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(200)

Unified Diff: media/cdm/proxy_decryptor.cc

Issue 1712903002: Remove prefixed EME. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Fix layout tests. Created 4 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
Index: media/cdm/proxy_decryptor.cc
diff --git a/media/cdm/proxy_decryptor.cc b/media/cdm/proxy_decryptor.cc
deleted file mode 100644
index 8d0085b58513ef1848f0c8cc33a3ed0862f25703..0000000000000000000000000000000000000000
--- a/media/cdm/proxy_decryptor.cc
+++ /dev/null
@@ -1,415 +0,0 @@
-// 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 "media/cdm/proxy_decryptor.h"
-
-#include <stddef.h>
-#include <cstring>
-#include <utility>
-
-#include "base/bind.h"
-#include "base/callback_helpers.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/strings/string_util.h"
-#include "build/build_config.h"
-#include "media/base/cdm_callback_promise.h"
-#include "media/base/cdm_config.h"
-#include "media/base/cdm_factory.h"
-#include "media/base/cdm_key_information.h"
-#include "media/base/key_systems.h"
-#include "media/base/media_permission.h"
-#include "media/cdm/json_web_key.h"
-#include "media/cdm/key_system_names.h"
-
-namespace media {
-
-// Special system code to signal a closed persistent session in a SessionError()
-// call. This is needed because there is no SessionClosed() call in the prefixed
-// EME API.
-const int kSessionClosedSystemCode = 29127;
-
-ProxyDecryptor::PendingGenerateKeyRequestData::PendingGenerateKeyRequestData(
- EmeInitDataType init_data_type,
- const std::vector<uint8_t>& init_data)
- : init_data_type(init_data_type), init_data(init_data) {}
-
-ProxyDecryptor::PendingGenerateKeyRequestData::
- ~PendingGenerateKeyRequestData() {
-}
-
-ProxyDecryptor::ProxyDecryptor(MediaPermission* media_permission,
- bool use_hw_secure_codecs,
- const KeyAddedCB& key_added_cb,
- const KeyErrorCB& key_error_cb,
- const KeyMessageCB& key_message_cb)
- : is_creating_cdm_(false),
-#if defined(OS_CHROMEOS) || defined(OS_ANDROID)
- media_permission_(media_permission),
-#endif
- use_hw_secure_codecs_(use_hw_secure_codecs),
- key_added_cb_(key_added_cb),
- key_error_cb_(key_error_cb),
- key_message_cb_(key_message_cb),
- is_clear_key_(false),
- weak_ptr_factory_(this) {
- DCHECK(media_permission);
- DCHECK(!key_added_cb_.is_null());
- DCHECK(!key_error_cb_.is_null());
- DCHECK(!key_message_cb_.is_null());
-}
-
-ProxyDecryptor::~ProxyDecryptor() {
- // Destroy the decryptor explicitly before destroying the plugin.
- media_keys_ = nullptr;
-}
-
-void ProxyDecryptor::CreateCdm(CdmFactory* cdm_factory,
- const std::string& key_system,
- const GURL& security_origin,
- const CdmContextReadyCB& cdm_context_ready_cb) {
- DVLOG(1) << __FUNCTION__ << ": key_system = " << key_system;
- DCHECK(!is_creating_cdm_);
- DCHECK(!media_keys_);
-
- // TODO(sandersd): Trigger permissions check here and use it to determine
- // distinctive identifier support, instead of always requiring the
- // permission. http://crbug.com/455271
- CdmConfig cdm_config;
- cdm_config.allow_distinctive_identifier = true;
- cdm_config.allow_persistent_state = true;
- cdm_config.use_hw_secure_codecs = use_hw_secure_codecs_;
-
- is_creating_cdm_ = true;
-
- base::WeakPtr<ProxyDecryptor> weak_this = weak_ptr_factory_.GetWeakPtr();
- cdm_factory->Create(
- key_system, security_origin, cdm_config,
- base::Bind(&ProxyDecryptor::OnSessionMessage, weak_this),
- base::Bind(&ProxyDecryptor::OnSessionClosed, weak_this),
- base::Bind(&ProxyDecryptor::OnLegacySessionError, weak_this),
- base::Bind(&ProxyDecryptor::OnSessionKeysChange, weak_this),
- base::Bind(&ProxyDecryptor::OnSessionExpirationUpdate, weak_this),
- base::Bind(&ProxyDecryptor::OnCdmCreated, weak_this, key_system,
- security_origin, cdm_context_ready_cb));
-}
-
-void ProxyDecryptor::OnCdmCreated(const std::string& key_system,
- const GURL& security_origin,
- const CdmContextReadyCB& cdm_context_ready_cb,
- const scoped_refptr<MediaKeys>& cdm,
- const std::string& /* error_message */) {
- is_creating_cdm_ = false;
-
- if (!cdm) {
- cdm_context_ready_cb.Run(nullptr);
- } else {
- key_system_ = key_system;
- security_origin_ = security_origin;
- is_clear_key_ = IsClearKey(key_system) || IsExternalClearKey(key_system);
- media_keys_ = cdm;
-
- cdm_context_ready_cb.Run(media_keys_->GetCdmContext());
- }
-
- for (const auto& request : pending_requests_)
- GenerateKeyRequestInternal(request->init_data_type, request->init_data);
-
- pending_requests_.clear();
-}
-
-void ProxyDecryptor::GenerateKeyRequest(EmeInitDataType init_data_type,
- const uint8_t* init_data,
- int init_data_length) {
- std::vector<uint8_t> init_data_vector(init_data,
- init_data + init_data_length);
-
- if (is_creating_cdm_) {
- pending_requests_.push_back(
- new PendingGenerateKeyRequestData(init_data_type, init_data_vector));
- return;
- }
-
- GenerateKeyRequestInternal(init_data_type, init_data_vector);
-}
-
-// Returns true if |data| is prefixed with |header| and has data after the
-// |header|.
-static bool HasHeader(const std::vector<uint8_t>& data,
- const std::string& header) {
- return data.size() > header.size() &&
- std::equal(header.begin(), header.end(), data.begin());
-}
-
-// Removes the first |length| items from |data|.
-static void StripHeader(std::vector<uint8_t>& data, size_t length) {
- data.erase(data.begin(), data.begin() + length);
-}
-
-void ProxyDecryptor::GenerateKeyRequestInternal(
- EmeInitDataType init_data_type,
- const std::vector<uint8_t>& init_data) {
- DVLOG(1) << __FUNCTION__;
- DCHECK(!is_creating_cdm_);
-
- if (!media_keys_) {
- OnLegacySessionError(std::string(), MediaKeys::NOT_SUPPORTED_ERROR, 0,
- "CDM creation failed.");
- return;
- }
-
- const char kPrefixedApiPersistentSessionHeader[] = "PERSISTENT|";
- const char kPrefixedApiLoadSessionHeader[] = "LOAD_SESSION|";
-
- SessionCreationType session_creation_type = TemporarySession;
- std::vector<uint8_t> stripped_init_data = init_data;
- if (HasHeader(init_data, kPrefixedApiLoadSessionHeader)) {
- session_creation_type = LoadSession;
- StripHeader(stripped_init_data, strlen(kPrefixedApiLoadSessionHeader));
- } else if (HasHeader(init_data, kPrefixedApiPersistentSessionHeader)) {
- session_creation_type = PersistentSession;
- StripHeader(stripped_init_data,
- strlen(kPrefixedApiPersistentSessionHeader));
- }
-
- scoped_ptr<NewSessionCdmPromise> promise(new CdmCallbackPromise<std::string>(
- base::Bind(&ProxyDecryptor::SetSessionId, weak_ptr_factory_.GetWeakPtr(),
- session_creation_type),
- base::Bind(&ProxyDecryptor::OnLegacySessionError,
- weak_ptr_factory_.GetWeakPtr(),
- std::string()))); // No session id until created.
-
- if (session_creation_type == LoadSession) {
- media_keys_->LoadSession(
- MediaKeys::PERSISTENT_LICENSE_SESSION,
- std::string(reinterpret_cast<const char*>(stripped_init_data.data()),
- stripped_init_data.size()),
- std::move(promise));
- return;
- }
-
- MediaKeys::SessionType session_type =
- session_creation_type == PersistentSession
- ? MediaKeys::PERSISTENT_LICENSE_SESSION
- : MediaKeys::TEMPORARY_SESSION;
-
- // No permission required when AesDecryptor is used or when the key system is
- // external clear key.
- DCHECK(!key_system_.empty());
- if (CanUseAesDecryptor(key_system_) || IsExternalClearKey(key_system_)) {
- OnPermissionStatus(session_type, init_data_type, stripped_init_data,
- std::move(promise), true /* granted */);
- return;
- }
-
-#if defined(OS_CHROMEOS) || defined(OS_ANDROID)
- media_permission_->RequestPermission(
- MediaPermission::PROTECTED_MEDIA_IDENTIFIER, security_origin_,
- base::Bind(&ProxyDecryptor::OnPermissionStatus,
- weak_ptr_factory_.GetWeakPtr(), session_type, init_data_type,
- stripped_init_data, base::Passed(&promise)));
-#else
- OnPermissionStatus(session_type, init_data_type, stripped_init_data,
- std::move(promise), true /* granted */);
-#endif
-}
-
-void ProxyDecryptor::OnPermissionStatus(
- MediaKeys::SessionType session_type,
- EmeInitDataType init_data_type,
- const std::vector<uint8_t>& init_data,
- scoped_ptr<NewSessionCdmPromise> promise,
- bool granted) {
- // ProxyDecryptor is only used by Prefixed EME, where RequestPermission() is
- // only for triggering the permission UI. Later CheckPermission() will be
- // called (e.g. in PlatformVerificationFlow on ChromeOS; in BrowserCdmManager
- // on Android) and the permission status will be evaluated then.
- DVLOG_IF(1, !granted) << "Permission request rejected.";
-
- media_keys_->CreateSessionAndGenerateRequest(session_type, init_data_type,
- init_data, std::move(promise));
-}
-
-void ProxyDecryptor::AddKey(const uint8_t* key,
- int key_length,
- const uint8_t* init_data,
- int init_data_length,
- const std::string& session_id) {
- DVLOG(1) << "AddKey()";
-
- if (!media_keys_) {
- OnLegacySessionError(std::string(), MediaKeys::INVALID_STATE_ERROR, 0,
- "CDM is not available.");
- return;
- }
-
- // In the prefixed API, the session parameter provided to addKey() is
- // optional, so use the single existing session if it exists.
- std::string new_session_id(session_id);
- if (new_session_id.empty()) {
- if (active_sessions_.size() == 1) {
- base::hash_map<std::string, bool>::iterator it = active_sessions_.begin();
- new_session_id = it->first;
- } else {
- OnLegacySessionError(std::string(), MediaKeys::NOT_SUPPORTED_ERROR, 0,
- "SessionId not specified.");
- return;
- }
- }
-
- scoped_ptr<SimpleCdmPromise> promise(new CdmCallbackPromise<>(
- base::Bind(&ProxyDecryptor::GenerateKeyAdded,
- weak_ptr_factory_.GetWeakPtr(), session_id),
- base::Bind(&ProxyDecryptor::OnLegacySessionError,
- weak_ptr_factory_.GetWeakPtr(), session_id)));
-
- // EME WD spec only supports a single array passed to the CDM. For
- // Clear Key using v0.1b, both arrays are used (|init_data| is key_id).
- // Since the EME WD spec supports the key as a JSON Web Key,
- // convert the 2 arrays to a JWK and pass it as the single array.
- if (is_clear_key_) {
- // Decryptor doesn't support empty key ID (see http://crbug.com/123265).
- // So ensure a non-empty value is passed.
- if (!init_data) {
- static const uint8_t kDummyInitData[1] = {0};
- init_data = kDummyInitData;
- init_data_length = arraysize(kDummyInitData);
- }
-
- std::string jwk =
- GenerateJWKSet(key, key_length, init_data, init_data_length);
- DCHECK(!jwk.empty());
- media_keys_->UpdateSession(new_session_id,
- std::vector<uint8_t>(jwk.begin(), jwk.end()),
- std::move(promise));
- return;
- }
-
- media_keys_->UpdateSession(new_session_id,
- std::vector<uint8_t>(key, key + key_length),
- std::move(promise));
-}
-
-void ProxyDecryptor::CancelKeyRequest(const std::string& session_id) {
- DVLOG(1) << "CancelKeyRequest()";
-
- if (!media_keys_) {
- OnLegacySessionError(std::string(), MediaKeys::INVALID_STATE_ERROR, 0,
- "CDM is not available.");
- return;
- }
-
- scoped_ptr<SimpleCdmPromise> promise(new CdmCallbackPromise<>(
- base::Bind(&ProxyDecryptor::OnSessionClosed,
- weak_ptr_factory_.GetWeakPtr(), session_id),
- base::Bind(&ProxyDecryptor::OnLegacySessionError,
- weak_ptr_factory_.GetWeakPtr(), session_id)));
- media_keys_->RemoveSession(session_id, std::move(promise));
-}
-
-void ProxyDecryptor::OnSessionMessage(const std::string& session_id,
- MediaKeys::MessageType message_type,
- const std::vector<uint8_t>& message,
- const GURL& legacy_destination_url) {
- // Assumes that OnSessionCreated() has been called before this.
-
- // For ClearKey, convert the message from JSON into just passing the key
- // as the message. If unable to extract the key, return the message unchanged.
- if (is_clear_key_) {
- std::vector<uint8_t> key;
- if (ExtractFirstKeyIdFromLicenseRequest(message, &key)) {
- key_message_cb_.Run(session_id, key, legacy_destination_url);
- return;
- }
- }
-
- key_message_cb_.Run(session_id, message, legacy_destination_url);
-}
-
-void ProxyDecryptor::OnSessionKeysChange(const std::string& session_id,
- bool has_additional_usable_key,
- CdmKeysInfo keys_info) {
- // EME v0.1b doesn't support this event.
-}
-
-void ProxyDecryptor::OnSessionExpirationUpdate(
- const std::string& session_id,
- const base::Time& new_expiry_time) {
- // EME v0.1b doesn't support this event.
-}
-
-void ProxyDecryptor::GenerateKeyAdded(const std::string& session_id) {
- // EME WD doesn't support this event, but it is needed for EME v0.1b.
- key_added_cb_.Run(session_id);
-}
-
-void ProxyDecryptor::OnSessionClosed(const std::string& session_id) {
- base::hash_map<std::string, bool>::iterator it =
- active_sessions_.find(session_id);
-
- // Latest EME spec separates closing a session ("allows an application to
- // indicate that it no longer needs the session") and actually closing the
- // session (done by the CDM at any point "such as in response to a close()
- // call, when the session is no longer needed, or when system resources are
- // lost.") Thus the CDM may cause 2 close() events -- one to resolve the
- // close() promise, and a second to actually close the session. Prefixed EME
- // only expects 1 close event, so drop the second (and subsequent) events.
- // However, this means we can't tell if the CDM is generating spurious close()
- // events.
- if (it == active_sessions_.end())
- return;
-
- if (it->second) {
- OnLegacySessionError(session_id, MediaKeys::NOT_SUPPORTED_ERROR,
- kSessionClosedSystemCode,
- "Do not close persistent sessions.");
- }
- active_sessions_.erase(it);
-}
-
-void ProxyDecryptor::OnLegacySessionError(const std::string& session_id,
- MediaKeys::Exception exception_code,
- uint32_t system_code,
- const std::string& error_message) {
- // Convert |error_name| back to MediaKeys::KeyError if possible. Prefixed
- // EME has different error message, so all the specific error events will
- // get lost.
- MediaKeys::KeyError error_code;
- switch (exception_code) {
- case MediaKeys::CLIENT_ERROR:
- error_code = MediaKeys::kClientError;
- break;
- case MediaKeys::OUTPUT_ERROR:
- error_code = MediaKeys::kOutputError;
- break;
- default:
- // This will include all other CDM4 errors and any error generated
- // by CDM5 or later.
- error_code = MediaKeys::kUnknownError;
- break;
- }
- key_error_cb_.Run(session_id, error_code, system_code);
-}
-
-void ProxyDecryptor::SetSessionId(SessionCreationType session_type,
- const std::string& session_id) {
- // LoadSession() returns empty |session_id| if the session is not found, so
- // convert this into an error.
- if (session_type == LoadSession && session_id.empty()) {
- OnLegacySessionError(session_id, MediaKeys::INVALID_ACCESS_ERROR, 0,
- "Incorrect session id specified for LoadSession().");
- return;
- }
-
- // Loaded sessions are considered persistent.
- bool is_persistent =
- session_type == PersistentSession || session_type == LoadSession;
- active_sessions_.insert(std::make_pair(session_id, is_persistent));
-
- // For LoadSession(), generate the KeyAdded event.
- if (session_type == LoadSession)
- GenerateKeyAdded(session_id);
-}
-
-} // namespace media

Powered by Google App Engine
This is Rietveld 408576698