233 lines
8.8 KiB
C++
233 lines
8.8 KiB
C++
// Copyright 2014 Google Inc. All rights reserved.
|
|
//
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file or at
|
|
// https://developers.google.com/open-source/licenses/bsd
|
|
|
|
#include "media/base/widevine_encryptor_source.h"
|
|
|
|
#include "base/base64.h"
|
|
#include "base/strings/stringprintf.h"
|
|
#include "media/base/http_fetcher.h"
|
|
#include "media/base/request_signer.h"
|
|
#include "media/base/status_test_util.h"
|
|
#include "testing/gmock/include/gmock/gmock.h"
|
|
#include "testing/gtest/include/gtest/gtest.h"
|
|
|
|
namespace {
|
|
const char kServerUrl[] = "http://www.foo.com/getcontentkey";
|
|
const char kContentId[] = "ContentFoo";
|
|
const char kTrackType[] = "SD";
|
|
const char kSignerName[] = "SignerFoo";
|
|
|
|
const char kMockSignature[] = "MockSignature";
|
|
|
|
const char kMockKeyId[] = "MockKeyId";
|
|
const char kMockKey[] = "MockKey";
|
|
const char kMockPsshData[] = "MockPsshData";
|
|
|
|
// The lisence service may return an error indicating a transient error has
|
|
// just happened in the server, or other types of errors.
|
|
// WidevineEncryptorSource will perform a number of retries on transient errors;
|
|
// WidevineEncryptorSource does not know about other errors and retries are not
|
|
// performed.
|
|
const char kLicenseStatusTransientError[] = "INTERNAL_ERROR";
|
|
const char kLicenseStatusUnknownError[] = "UNKNOWN_ERROR";
|
|
|
|
const char kExpectedRequestMessageFormat[] =
|
|
"{\"content_id\":\"%s\",\"drm_types\":[\"WIDEVINE\"],\"policy\":\"\","
|
|
"\"tracks\":[{\"type\":\"SD\"},{\"type\":\"HD\"},{\"type\":\"AUDIO\"}]}";
|
|
const char kExpectedSignedMessageFormat[] =
|
|
"{\"request\":\"%s\",\"signature\":\"%s\",\"signer\":\"%s\"}";
|
|
const char kLicenseOkResponseFormat[] =
|
|
"{\"status\":\"OK\",\"tracks\":[{\"type\":\"%s\",\"key_id\":\"%s\",\"key\":"
|
|
"\"%s\",\"pssh\":[{\"drm_type\":\"WIDEVINE\",\"data\":\"%s\"}]}]}";
|
|
const char kLicenseErrorResponseFormat[] =
|
|
"{\"status\":\"%s\",\"drm\":[],\"tracks\":[]}";
|
|
const char kHttpResponseFormat[] = "{\"response\":\"%s\"}";
|
|
|
|
std::string Base64Encode(const std::string& input) {
|
|
std::string output;
|
|
base::Base64Encode(input, &output);
|
|
return output;
|
|
}
|
|
|
|
std::string ToString(const std::vector<uint8> v) {
|
|
return std::string(v.begin(), v.end());
|
|
}
|
|
} // namespace
|
|
|
|
using ::testing::_;
|
|
using ::testing::DoAll;
|
|
using ::testing::Return;
|
|
using ::testing::SetArgPointee;
|
|
|
|
namespace media {
|
|
|
|
class MockRequestSigner : public RequestSigner {
|
|
public:
|
|
explicit MockRequestSigner(const std::string& signer_name)
|
|
: RequestSigner(signer_name) {}
|
|
virtual ~MockRequestSigner() {}
|
|
|
|
MOCK_METHOD2(GenerateSignature,
|
|
bool(const std::string& message, std::string* signature));
|
|
|
|
private:
|
|
DISALLOW_COPY_AND_ASSIGN(MockRequestSigner);
|
|
};
|
|
|
|
class MockHttpFetcher : public HttpFetcher {
|
|
public:
|
|
MockHttpFetcher() : HttpFetcher() {}
|
|
virtual ~MockHttpFetcher() {}
|
|
|
|
MOCK_METHOD2(Get, Status(const std::string& url, std::string* response));
|
|
MOCK_METHOD3(Post,
|
|
Status(const std::string& url,
|
|
const std::string& data,
|
|
std::string* response));
|
|
|
|
private:
|
|
DISALLOW_COPY_AND_ASSIGN(MockHttpFetcher);
|
|
};
|
|
|
|
class WidevineEncryptorSourceTest : public ::testing::Test {
|
|
public:
|
|
WidevineEncryptorSourceTest()
|
|
: mock_request_signer_(new MockRequestSigner(kSignerName)),
|
|
mock_http_fetcher_(new MockHttpFetcher()) {}
|
|
|
|
protected:
|
|
void CreateWidevineEncryptorSource() {
|
|
widevine_encryptor_source_.reset(new WidevineEncryptorSource(
|
|
kServerUrl,
|
|
kContentId,
|
|
WidevineEncryptorSource::GetTrackTypeFromString(kTrackType),
|
|
mock_request_signer_.PassAs<RequestSigner>()));
|
|
widevine_encryptor_source_->set_http_fetcher(
|
|
mock_http_fetcher_.PassAs<HttpFetcher>());
|
|
}
|
|
|
|
scoped_ptr<MockRequestSigner> mock_request_signer_;
|
|
scoped_ptr<MockHttpFetcher> mock_http_fetcher_;
|
|
scoped_ptr<WidevineEncryptorSource> widevine_encryptor_source_;
|
|
|
|
private:
|
|
DISALLOW_COPY_AND_ASSIGN(WidevineEncryptorSourceTest);
|
|
};
|
|
|
|
TEST_F(WidevineEncryptorSourceTest, GetTrackTypeFromString) {
|
|
EXPECT_EQ(WidevineEncryptorSource::TRACK_TYPE_SD,
|
|
WidevineEncryptorSource::GetTrackTypeFromString("SD"));
|
|
EXPECT_EQ(WidevineEncryptorSource::TRACK_TYPE_HD,
|
|
WidevineEncryptorSource::GetTrackTypeFromString("HD"));
|
|
EXPECT_EQ(WidevineEncryptorSource::TRACK_TYPE_AUDIO,
|
|
WidevineEncryptorSource::GetTrackTypeFromString("AUDIO"));
|
|
EXPECT_EQ(WidevineEncryptorSource::TRACK_TYPE_UNKNOWN,
|
|
WidevineEncryptorSource::GetTrackTypeFromString("FOO"));
|
|
}
|
|
|
|
TEST_F(WidevineEncryptorSourceTest, GeneratureSignatureFailure) {
|
|
EXPECT_CALL(*mock_request_signer_, GenerateSignature(_, _))
|
|
.WillOnce(Return(false));
|
|
|
|
CreateWidevineEncryptorSource();
|
|
ASSERT_EQ(Status(error::INTERNAL_ERROR, "Signature generation failed."),
|
|
widevine_encryptor_source_->Initialize());
|
|
}
|
|
|
|
// Check whether expected request message and post data was generated and
|
|
// verify the correct behavior on http failure.
|
|
TEST_F(WidevineEncryptorSourceTest, HttpPostFailure) {
|
|
std::string expected_message = base::StringPrintf(
|
|
kExpectedRequestMessageFormat, Base64Encode(kContentId).c_str());
|
|
EXPECT_CALL(*mock_request_signer_, GenerateSignature(expected_message, _))
|
|
.WillOnce(DoAll(SetArgPointee<1>(kMockSignature), Return(true)));
|
|
|
|
std::string expected_post_data =
|
|
base::StringPrintf(kExpectedSignedMessageFormat,
|
|
Base64Encode(expected_message).c_str(),
|
|
Base64Encode(kMockSignature).c_str(),
|
|
kSignerName);
|
|
const Status kMockStatus = Status::UNKNOWN;
|
|
EXPECT_CALL(*mock_http_fetcher_, Post(kServerUrl, expected_post_data, _))
|
|
.WillOnce(Return(kMockStatus));
|
|
|
|
CreateWidevineEncryptorSource();
|
|
ASSERT_EQ(kMockStatus, widevine_encryptor_source_->Initialize());
|
|
}
|
|
|
|
TEST_F(WidevineEncryptorSourceTest, LicenseStatusOK) {
|
|
EXPECT_CALL(*mock_request_signer_, GenerateSignature(_, _))
|
|
.WillOnce(Return(true));
|
|
|
|
std::string mock_license_status =
|
|
base::StringPrintf(kLicenseOkResponseFormat,
|
|
kTrackType,
|
|
Base64Encode(kMockKeyId).c_str(),
|
|
Base64Encode(kMockKey).c_str(),
|
|
Base64Encode(kMockPsshData).c_str());
|
|
std::string expected_response = base::StringPrintf(
|
|
kHttpResponseFormat, Base64Encode(mock_license_status).c_str());
|
|
|
|
EXPECT_CALL(*mock_http_fetcher_, Post(_, _, _))
|
|
.WillOnce(DoAll(SetArgPointee<2>(expected_response), Return(Status::OK)));
|
|
|
|
CreateWidevineEncryptorSource();
|
|
ASSERT_OK(widevine_encryptor_source_->Initialize());
|
|
EXPECT_EQ(kMockKeyId, ToString(widevine_encryptor_source_->key_id()));
|
|
EXPECT_EQ(kMockKey, ToString(widevine_encryptor_source_->key()));
|
|
EXPECT_EQ(kMockPsshData, ToString(widevine_encryptor_source_->pssh()));
|
|
}
|
|
|
|
TEST_F(WidevineEncryptorSourceTest, RetryOnTransientError) {
|
|
EXPECT_CALL(*mock_request_signer_, GenerateSignature(_, _))
|
|
.WillOnce(Return(true));
|
|
|
|
std::string mock_license_status = base::StringPrintf(
|
|
kLicenseErrorResponseFormat, kLicenseStatusTransientError);
|
|
std::string expected_response = base::StringPrintf(
|
|
kHttpResponseFormat, Base64Encode(mock_license_status).c_str());
|
|
|
|
std::string mock_retried_license_status =
|
|
base::StringPrintf(kLicenseOkResponseFormat,
|
|
kTrackType,
|
|
Base64Encode(kMockKeyId).c_str(),
|
|
Base64Encode(kMockKey).c_str(),
|
|
Base64Encode(kMockPsshData).c_str());
|
|
std::string expected_retried_response = base::StringPrintf(
|
|
kHttpResponseFormat, Base64Encode(mock_retried_license_status).c_str());
|
|
|
|
// Retry is expected on transient error.
|
|
EXPECT_CALL(*mock_http_fetcher_, Post(_, _, _))
|
|
.WillOnce(DoAll(SetArgPointee<2>(expected_response), Return(Status::OK)))
|
|
.WillOnce(DoAll(SetArgPointee<2>(expected_retried_response),
|
|
Return(Status::OK)));
|
|
|
|
CreateWidevineEncryptorSource();
|
|
ASSERT_OK(widevine_encryptor_source_->Initialize());
|
|
EXPECT_EQ(kMockKeyId, ToString(widevine_encryptor_source_->key_id()));
|
|
EXPECT_EQ(kMockKey, ToString(widevine_encryptor_source_->key()));
|
|
EXPECT_EQ(kMockPsshData, ToString(widevine_encryptor_source_->pssh()));
|
|
}
|
|
|
|
TEST_F(WidevineEncryptorSourceTest, NoRetryOnUnknownError) {
|
|
EXPECT_CALL(*mock_request_signer_, GenerateSignature(_, _))
|
|
.WillOnce(Return(true));
|
|
|
|
std::string mock_license_status = base::StringPrintf(
|
|
kLicenseErrorResponseFormat, kLicenseStatusUnknownError);
|
|
std::string mock_response = base::StringPrintf(
|
|
kHttpResponseFormat, Base64Encode(mock_license_status).c_str());
|
|
|
|
EXPECT_CALL(*mock_http_fetcher_, Post(_, _, _))
|
|
.WillOnce(DoAll(SetArgPointee<2>(mock_response), Return(Status::OK)));
|
|
|
|
CreateWidevineEncryptorSource();
|
|
ASSERT_EQ(error::SERVER_ERROR,
|
|
widevine_encryptor_source_->Initialize().error_code());
|
|
}
|
|
|
|
} // namespace media
|