diff --git a/libwvdrmengine/cdm/core/include/policy_engine.h b/libwvdrmengine/cdm/core/include/policy_engine.h index ccef771d..1d793fe6 100644 --- a/libwvdrmengine/cdm/core/include/policy_engine.h +++ b/libwvdrmengine/cdm/core/include/policy_engine.h @@ -111,10 +111,17 @@ class PolicyEngine { kLicenseStateExpired } LicenseState; - int64_t GetLicenseExpiryTime(); - int64_t GetPlaybackExpiryTime(); + // Gets the clock time that the license expires. This is the hard limit that + // all license types must obey at all times. + int64_t GetHardLicenseExpiryTime(); + // Gets the clock time that the rental duration will expire, using the license + // duration if one is not present. + int64_t GetRentalExpiryTime(); + // Gets the clock time that the license expires based on whether we have + // started playing. This takes into account GetHardLicenseExpiryTime. + int64_t GetExpiryTime(); - int64_t GetLicenseDurationRemaining(int64_t current_time); + int64_t GetLicenseOrRentalDurationRemaining(int64_t current_time); int64_t GetPlaybackDurationRemaining(int64_t current_time); bool IsRenewalDelayExpired(int64_t current_time); @@ -159,7 +166,6 @@ class PolicyEngine { // represents an offset from license_start_time_. This is used to // calculate the time where renewal retries should occur. int64_t next_renewal_time_; - int64_t policy_max_duration_seconds_; // Used to dispatch CDM events. CdmSessionId session_id_; diff --git a/libwvdrmengine/cdm/core/src/policy_engine.cpp b/libwvdrmengine/cdm/core/src/policy_engine.cpp index 6d885a21..8bb6289a 100644 --- a/libwvdrmengine/cdm/core/src/policy_engine.cpp +++ b/libwvdrmengine/cdm/core/src/policy_engine.cpp @@ -33,7 +33,6 @@ PolicyEngine::PolicyEngine(CdmSessionId session_id, last_expiry_time_(0), last_expiry_time_set_(false), next_renewal_time_(0), - policy_max_duration_seconds_(0), session_id_(session_id), event_listener_(event_listener), license_keys_(new LicenseKeys), @@ -179,21 +178,6 @@ void PolicyEngine::UpdateLicense(const License& license) { license_start_time_ = license.license_start_time(); next_renewal_time_ = license_start_time_ + policy_.renewal_delay_seconds(); - // Calculate policy_max_duration_seconds_. policy_max_duration_seconds_ - // will be set to the minimum of the following policies : - // rental_duration_seconds and license_duration_seconds. - // The value is used to determine when the license expires. - policy_max_duration_seconds_ = 0; - - if (policy_.has_rental_duration_seconds()) - policy_max_duration_seconds_ = policy_.rental_duration_seconds(); - - if ((policy_.license_duration_seconds() > 0) && - ((policy_.license_duration_seconds() < policy_max_duration_seconds_) || - policy_max_duration_seconds_ == 0)) { - policy_max_duration_seconds_ = policy_.license_duration_seconds(); - } - int64_t current_time = clock_->GetCurrentTime(); if (!policy_.can_play() || IsLicenseOrPlaybackDurationExpired(current_time)) { license_state_ = kLicenseStateExpired; @@ -267,7 +251,7 @@ CdmResponseType PolicyEngine::Query(CdmQueryMap* query_response) { policy_.can_persist() ? QUERY_VALUE_TRUE : QUERY_VALUE_FALSE; (*query_response)[QUERY_KEY_RENEW_ALLOWED] = policy_.can_renew() ? QUERY_VALUE_TRUE : QUERY_VALUE_FALSE; - ss << GetLicenseDurationRemaining(current_time); + ss << GetLicenseOrRentalDurationRemaining(current_time); (*query_response)[QUERY_KEY_LICENSE_DURATION_REMAINING] = ss.str(); ss.str(""); ss << GetPlaybackDurationRemaining(current_time); @@ -305,8 +289,10 @@ bool PolicyEngine::GetSecondsSinceLastPlayed( int64_t PolicyEngine::GetLicenseOrPlaybackDurationRemaining() { int64_t current_time = clock_->GetCurrentTime(); - return std::min(GetLicenseDurationRemaining(current_time), - GetPlaybackDurationRemaining(current_time)); + const int64_t expiry_time = GetExpiryTime(); + if (expiry_time == NEVER_EXPIRES) return LLONG_MAX; + if (expiry_time < current_time) return 0; + return expiry_time - current_time; } void PolicyEngine::RestorePlaybackTimes(int64_t playback_start_time, @@ -322,42 +308,64 @@ void PolicyEngine::UpdateRenewalRequest(int64_t current_time) { } bool PolicyEngine::IsLicenseOrPlaybackDurationExpired(int64_t current_time) { - int64_t expiry_time = - IsPlaybackStarted() ? GetPlaybackExpiryTime() : GetLicenseExpiryTime(); + const int64_t expiry_time = GetExpiryTime(); return (expiry_time == NEVER_EXPIRES) ? false : (expiry_time <= current_time); } // For the policy time fields checked in the following methods, a value of 0 -// indicates that there is no limit to the duration. These methods -// will always return false if the value is 0. -int64_t PolicyEngine::GetLicenseExpiryTime() { - return policy_max_duration_seconds_ > 0 - ? license_start_time_ + policy_max_duration_seconds_ +// indicates that there is no limit to the duration. If the fields are zero +// (including the hard limit) then these methods will return NEVER_EXPIRES. + +int64_t PolicyEngine::GetHardLicenseExpiryTime() { + return policy_.license_duration_seconds() > 0 + ? license_start_time_ + policy_.license_duration_seconds() : NEVER_EXPIRES; } -int64_t PolicyEngine::GetPlaybackExpiryTime() { - return (playback_start_time_ > 0 && policy_.playback_duration_seconds() > 0) - ? (playback_start_time_ + policy_.playback_duration_seconds()) - : NEVER_EXPIRES; +int64_t PolicyEngine::GetRentalExpiryTime() { + const int64_t hard_limit = GetHardLicenseExpiryTime(); + if (policy_.rental_duration_seconds() == 0) return hard_limit; + const int64_t expiry_time = + license_start_time_ + policy_.rental_duration_seconds(); + if (hard_limit == NEVER_EXPIRES) return expiry_time; + return std::min(hard_limit, expiry_time); } -int64_t PolicyEngine::GetLicenseDurationRemaining(int64_t current_time) { - int64_t license_expiry_time = GetLicenseExpiryTime(); +int64_t PolicyEngine::GetExpiryTime() { + if (!IsPlaybackStarted()) + return GetRentalExpiryTime(); + + const int64_t hard_limit = GetHardLicenseExpiryTime(); + if (policy_.playback_duration_seconds() == 0) return hard_limit; + const int64_t expiry_time = + playback_start_time_ + policy_.playback_duration_seconds(); + + if (hard_limit == NEVER_EXPIRES) + return expiry_time; + return std::min(hard_limit, expiry_time); +} + +int64_t PolicyEngine::GetLicenseOrRentalDurationRemaining( + int64_t current_time) { + // This is only used in Query. This should return the time remaining on + // license_duration_seconds for streaming licenses and rental_duration_seconds + // for offline licenses. + if (IsLicenseOrPlaybackDurationExpired(current_time)) return 0; + const int64_t license_expiry_time = GetRentalExpiryTime(); if (license_expiry_time == NEVER_EXPIRES) return LLONG_MAX; if (license_expiry_time < current_time) return 0; return std::min(license_expiry_time - current_time, - policy_max_duration_seconds_); + policy_.license_duration_seconds()); } int64_t PolicyEngine::GetPlaybackDurationRemaining(int64_t current_time) { - int64_t playback_expiry_time = GetPlaybackExpiryTime(); - if (playback_expiry_time == NEVER_EXPIRES) { - return (policy_.playback_duration_seconds() != 0) - ? policy_.playback_duration_seconds() - : LLONG_MAX; - } + // This is only used in Query. This should return playback_duration_seconds, + // or the time remaining on it if playing. + const int64_t playback_duration = policy_.playback_duration_seconds(); + if (playback_duration == 0) return LLONG_MAX; + if (playback_start_time_ == 0) return playback_duration; + const int64_t playback_expiry_time = playback_duration + playback_start_time_; if (playback_expiry_time < current_time) return 0; return std::min(playback_expiry_time - current_time, policy_.playback_duration_seconds()); @@ -395,8 +403,7 @@ void PolicyEngine::NotifyKeysChange(CdmKeyStatus new_status) { } void PolicyEngine::NotifyExpirationUpdate() { - int64_t expiry_time = - IsPlaybackStarted() ? GetPlaybackExpiryTime() : GetLicenseExpiryTime(); + const int64_t expiry_time = GetExpiryTime(); if (!last_expiry_time_set_ || expiry_time != last_expiry_time_) { last_expiry_time_ = expiry_time; if (event_listener_) diff --git a/libwvdrmengine/cdm/core/test/policy_engine_unittest.cpp b/libwvdrmengine/cdm/core/test/policy_engine_unittest.cpp index a74dcc3e..566e5d14 100644 --- a/libwvdrmengine/cdm/core/test/policy_engine_unittest.cpp +++ b/libwvdrmengine/cdm/core/test/policy_engine_unittest.cpp @@ -24,19 +24,13 @@ const int64_t kLicenseStartTime = 1413517500; // ~ 01/01/2013 const int64_t kPlaybackStartTime = kLicenseStartTime + 5; const int64_t kRentalDuration = 604800; // 7 days const int64_t kPlaybackDuration = 172800; // 48 hours -const int64_t kStreamingLicenseDuration = 300; // 5 minutes -const int64_t kOfflineLicenseDuration = kRentalDuration; +const int64_t kLicenseDuration = kRentalDuration + kPlaybackDuration; const int64_t kLicenseRenewalPeriod = 120; // 2 minutes const int64_t kLicenseRenewalRetryInterval = 30; // 30 seconds const int64_t kLicenseRenewalRecoveryDuration = 30; // 30 seconds -const int64_t kLowDuration = - std::min(std::min(std::min(kRentalDuration, kPlaybackDuration), - kStreamingLicenseDuration), - kOfflineLicenseDuration); +const int64_t kLowDuration = 300; // 5 minutes const int64_t kHighDuration = - std::max(std::max(std::max(kRentalDuration, kPlaybackDuration), - kStreamingLicenseDuration), - kOfflineLicenseDuration); + std::max(std::max(kRentalDuration, kPlaybackDuration), kLicenseDuration); const char* kRenewalServerUrl = "https://test.google.com/license/GetCencLicense"; const KeyId kKeyId = "357adc89f1673433c36c621f1b5c41ee"; @@ -51,6 +45,13 @@ int64_t GetLicenseRenewalDelay(int64_t license_duration) { : 0; } +int64_t ParseInt(const std::string& str) { + std::stringstream ss(str); + int64_t ret; + ss >> ret; + return ret; +} + class MockCdmEventListener : public WvCdmEventListener { public: MOCK_METHOD1(OnSessionRenewalNeeded, void(const CdmSessionId& session_id)); @@ -101,32 +102,20 @@ class PolicyEngineTest : public ::testing::Test { policy = license_.mutable_policy(); policy->set_can_play(true); policy->set_can_persist(false); - policy->set_can_renew(true); + policy->set_can_renew(false); + // This is similar to an OFFLINE policy. policy->set_rental_duration_seconds(kRentalDuration); policy->set_playback_duration_seconds(kPlaybackDuration); - policy->set_license_duration_seconds(kStreamingLicenseDuration); + policy->set_license_duration_seconds(kLicenseDuration); policy->set_renewal_recovery_duration_seconds( kLicenseRenewalRecoveryDuration); policy->set_renewal_server_url(kRenewalServerUrl); - policy->set_renewal_delay_seconds( - GetLicenseRenewalDelay(kStreamingLicenseDuration)); + policy->set_renewal_delay_seconds(0); policy->set_renewal_retry_interval_seconds(kLicenseRenewalRetryInterval); policy->set_renew_with_usage(false); } - int64_t GetMinOfRentalPlaybackLicenseDurations() { - const License_Policy& policy = license_.policy(); - int64_t rental_duration = policy.rental_duration_seconds(); - int64_t playback_duration = policy.playback_duration_seconds(); - int64_t license_duration = policy.license_duration_seconds(); - if (rental_duration == kDurationUnlimited) rental_duration = LLONG_MAX; - if (playback_duration == kDurationUnlimited) playback_duration = LLONG_MAX; - if (license_duration == kDurationUnlimited) license_duration = LLONG_MAX; - return std::min(std::min(rental_duration, playback_duration), - license_duration); - } - void InjectMockClock() { mock_clock_ = new MockClock(); policy_engine_->set_clock(mock_clock_); @@ -163,7 +152,30 @@ TEST_F(PolicyEngineTest, NoLicense) { EXPECT_FALSE(policy_engine_->CanDecrypt(kKeyId)); } -TEST_F(PolicyEngineTest, PlaybackSuccess) { +TEST_F(PolicyEngineTest, PlaybackSuccess_OfflineLicense) { + EXPECT_CALL(*mock_clock_, GetCurrentTime()) + .WillOnce(Return(kLicenseStartTime + 1)) + .WillOnce(Return(kPlaybackStartTime)) + .WillOnce(Return(kLicenseStartTime + 10)); + + ExpectSessionKeysChange(kKeyStatusUsable, true); + EXPECT_CALL(mock_event_listener_, + OnExpirationUpdate(_, kLicenseStartTime + kRentalDuration)); + EXPECT_CALL(mock_event_listener_, + OnExpirationUpdate(_, kPlaybackStartTime + kPlaybackDuration)); + + policy_engine_->SetLicense(license_); + policy_engine_->BeginDecryption(); + policy_engine_->OnTimerEvent(); + + EXPECT_TRUE(policy_engine_->CanDecrypt(kKeyId)); + EXPECT_FALSE(policy_engine_->CanDecrypt(kSomeRandomKeyId)); +} + +TEST_F(PolicyEngineTest, PlaybackSuccess_StreamingLicense) { + License_Policy* policy = license_.mutable_policy(); + policy->set_license_duration_seconds(kLowDuration); + EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime + 1)) .WillOnce(Return(kPlaybackStartTime)) @@ -172,8 +184,6 @@ TEST_F(PolicyEngineTest, PlaybackSuccess) { ExpectSessionKeysChange(kKeyStatusUsable, true); EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, kLicenseStartTime + kLowDuration)); - EXPECT_CALL(mock_event_listener_, - OnExpirationUpdate(_, kPlaybackStartTime + kPlaybackDuration)); policy_engine_->SetLicense(license_); policy_engine_->BeginDecryption(); @@ -206,14 +216,12 @@ TEST_F(PolicyEngineTest, LicenseExpired_RentalDurationExpiredWithoutPlayback) { License_Policy* policy = license_.mutable_policy(); policy->set_rental_duration_seconds(kLowDuration); policy->set_license_duration_seconds(kHighDuration); - policy->set_renewal_delay_seconds(GetLicenseRenewalDelay(kHighDuration)); - int64_t min_duration = GetMinOfRentalPlaybackLicenseDurations(); EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime + 1)) .WillOnce(Return(kPlaybackStartTime)) - .WillOnce(Return(kLicenseStartTime + min_duration - 1)) - .WillOnce(Return(kLicenseStartTime + min_duration)); + .WillOnce(Return(kLicenseStartTime + kLowDuration - 1)) + .WillOnce(Return(kLicenseStartTime + kLowDuration)); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -235,18 +243,15 @@ TEST_F(PolicyEngineTest, LicenseExpired_RentalDurationExpiredWithoutPlayback) { EXPECT_FALSE(policy_engine_->CanDecrypt(kKeyId)); } -TEST_F(PolicyEngineTest, PlaybackOk_RentalDurationNotExpiredWithPlayback) { +TEST_F(PolicyEngineTest, PlaybackOk_RentalDurationPassedWithPlayback) { License_Policy* policy = license_.mutable_policy(); policy->set_rental_duration_seconds(kLowDuration); - policy->set_license_duration_seconds(kHighDuration); - policy->set_renewal_delay_seconds(GetLicenseRenewalDelay(kHighDuration)); - int64_t min_duration = GetMinOfRentalPlaybackLicenseDurations(); EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime + 1)) .WillOnce(Return(kPlaybackStartTime)) - .WillOnce(Return(kLicenseStartTime + min_duration - 1)) - .WillOnce(Return(kLicenseStartTime + min_duration)); + .WillOnce(Return(kLicenseStartTime + kLowDuration - 1)) + .WillOnce(Return(kLicenseStartTime + kLowDuration + 1)); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -270,9 +275,6 @@ TEST_F(PolicyEngineTest, PlaybackOk_RentalDurationNotExpiredWithPlayback) { } TEST_F(PolicyEngineTest, PlaybackFails_PlaybackDurationExpired) { - License_Policy* policy = license_.mutable_policy(); - policy->set_license_duration_seconds(kHighDuration); - policy->set_renewal_delay_seconds(GetLicenseRenewalDelay(kHighDuration)); int64_t playback_start_time = kLicenseStartTime + 10000; EXPECT_CALL(*mock_clock_, GetCurrentTime()) @@ -284,7 +286,7 @@ TEST_F(PolicyEngineTest, PlaybackFails_PlaybackDurationExpired) { InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); EXPECT_CALL(mock_event_listener_, - OnExpirationUpdate(_, kLicenseStartTime + kHighDuration)); + OnExpirationUpdate(_, kLicenseStartTime + kRentalDuration)); EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, playback_start_time + kPlaybackDuration)); EXPECT_CALL(check_, Call(1)); @@ -305,14 +307,13 @@ TEST_F(PolicyEngineTest, PlaybackFails_PlaybackDurationExpired) { TEST_F(PolicyEngineTest, LicenseExpired_LicenseDurationExpiredWithoutPlayback) { License_Policy* policy = license_.mutable_policy(); - policy->set_can_renew(false); - int64_t min_duration = GetMinOfRentalPlaybackLicenseDurations(); + policy->set_license_duration_seconds(kLowDuration); EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime + 1)) .WillOnce(Return(kPlaybackStartTime)) - .WillOnce(Return(kLicenseStartTime + min_duration - 1)) - .WillOnce(Return(kLicenseStartTime + min_duration)); + .WillOnce(Return(kLicenseStartTime + kLowDuration - 1)) + .WillOnce(Return(kLicenseStartTime + kLowDuration)); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -334,24 +335,25 @@ TEST_F(PolicyEngineTest, LicenseExpired_LicenseDurationExpiredWithoutPlayback) { EXPECT_FALSE(policy_engine_->CanDecrypt(kKeyId)); } -TEST_F(PolicyEngineTest, PlaybackOk_LicenseDurationNotExpiredWithPlayback) { +TEST_F(PolicyEngineTest, PlaybackFails_ExpiryBeforeRenewalDelay_Offline) { License_Policy* policy = license_.mutable_policy(); - policy->set_can_renew(false); - int64_t min_duration = GetMinOfRentalPlaybackLicenseDurations(); + policy->set_renewal_delay_seconds(kLicenseDuration + 10); + policy->set_can_renew(true); EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime + 1)) .WillOnce(Return(kPlaybackStartTime)) - .WillOnce(Return(kLicenseStartTime + min_duration - 1)) - .WillOnce(Return(kLicenseStartTime + min_duration)); + .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration - 1)) + .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 1)); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); EXPECT_CALL(mock_event_listener_, - OnExpirationUpdate(_, kLicenseStartTime + kLowDuration)); + OnExpirationUpdate(_, kLicenseStartTime + kRentalDuration)); EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, kPlaybackStartTime + kPlaybackDuration)); EXPECT_CALL(check_, Call(1)); + ExpectSessionKeysChange(kKeyStatusExpired, false); EXPECT_CALL(check_, Call(2)); policy_engine_->SetLicense(license_); @@ -363,26 +365,26 @@ TEST_F(PolicyEngineTest, PlaybackOk_LicenseDurationNotExpiredWithPlayback) { check_.Call(i); } - EXPECT_TRUE(policy_engine_->CanDecrypt(kKeyId)); + EXPECT_FALSE(policy_engine_->CanDecrypt(kKeyId)); } -TEST_F(PolicyEngineTest, PlaybackFails_ExpiryBeforeRenewalDelay) { +TEST_F(PolicyEngineTest, PlaybackFails_ExpiryBeforeRenewalDelay_Streaming) { License_Policy* policy = license_.mutable_policy(); - policy->set_renewal_delay_seconds(kStreamingLicenseDuration + 10); - int64_t min_duration = GetMinOfRentalPlaybackLicenseDurations(); + policy->clear_rental_duration_seconds(); + policy->clear_playback_duration_seconds(); + policy->set_renewal_delay_seconds(kLicenseDuration + 10); + policy->set_can_renew(true); EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime + 1)) .WillOnce(Return(kPlaybackStartTime)) - .WillOnce(Return(kLicenseStartTime + min_duration - 1)) - .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration)); + .WillOnce(Return(kLicenseStartTime + kLicenseDuration - 1)) + .WillOnce(Return(kLicenseStartTime + kLicenseDuration + 1)); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); EXPECT_CALL(mock_event_listener_, - OnExpirationUpdate(_, kLicenseStartTime + kLowDuration)); - EXPECT_CALL(mock_event_listener_, - OnExpirationUpdate(_, kPlaybackStartTime + kPlaybackDuration)); + OnExpirationUpdate(_, kLicenseStartTime + kLicenseDuration)); EXPECT_CALL(check_, Call(1)); ExpectSessionKeysChange(kKeyStatusExpired, false); EXPECT_CALL(check_, Call(2)); @@ -402,35 +404,25 @@ TEST_F(PolicyEngineTest, PlaybackFails_ExpiryBeforeRenewalDelay) { TEST_F(PolicyEngineTest, PlaybackOk_RentalDuration0) { License_Policy* policy = license_.mutable_policy(); policy->set_rental_duration_seconds(kDurationUnlimited); - int64_t license_renewal_delay = - GetLicenseRenewalDelay(kStreamingLicenseDuration); EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime + 1)) - .WillOnce(Return(kPlaybackStartTime)) - .WillOnce(Return(kLicenseStartTime + license_renewal_delay - 1)) - .WillOnce(Return(kLicenseStartTime + license_renewal_delay)) - .WillOnce(Return(kLicenseStartTime + kStreamingLicenseDuration - 1)) - .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration)); + .WillOnce(Return(kLicenseStartTime + kRentalDuration - 1)) + .WillOnce(Return(kLicenseStartTime + kRentalDuration + 10)) + .WillOnce(Return(kLicenseStartTime + kLicenseDuration + 1)); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); EXPECT_CALL(mock_event_listener_, - OnExpirationUpdate(_, kLicenseStartTime + kLowDuration)); - EXPECT_CALL(mock_event_listener_, - OnExpirationUpdate(_, kPlaybackStartTime + kPlaybackDuration)); + OnExpirationUpdate(_, kLicenseStartTime + kLicenseDuration)); EXPECT_CALL(check_, Call(1)); - EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)); EXPECT_CALL(check_, Call(2)); - EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)); - EXPECT_CALL(check_, Call(3)); ExpectSessionKeysChange(kKeyStatusExpired, false); - EXPECT_CALL(check_, Call(4)); + EXPECT_CALL(check_, Call(3)); policy_engine_->SetLicense(license_); - policy_engine_->BeginDecryption(); - for (int i = 1; i <= 4; ++i) { + for (int i = 1; i <= 3; ++i) { EXPECT_TRUE(policy_engine_->CanDecrypt(kKeyId)); policy_engine_->OnTimerEvent(); check_.Call(i); @@ -442,29 +434,25 @@ TEST_F(PolicyEngineTest, PlaybackOk_RentalDuration0) { TEST_F(PolicyEngineTest, PlaybackOk_PlaybackDuration0) { License_Policy* policy = license_.mutable_policy(); policy->set_playback_duration_seconds(kDurationUnlimited); - policy->set_license_duration_seconds(kHighDuration); - int64_t license_renewal_delay = GetLicenseRenewalDelay(kHighDuration); - policy->set_renewal_delay_seconds(license_renewal_delay); EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime)) .WillOnce(Return(kPlaybackStartTime)) - .WillOnce(Return(kLicenseStartTime + license_renewal_delay - 2)) - .WillOnce(Return(kLicenseStartTime + license_renewal_delay + 2)) - .WillOnce(Return(kLicenseStartTime + kHighDuration - 2)) - .WillOnce(Return(kLicenseStartTime + kHighDuration + 2)); + .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration - 2)) + .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 2)) + .WillOnce(Return(kLicenseStartTime + kLicenseDuration - 2)) + .WillOnce(Return(kLicenseStartTime + kLicenseDuration + 2)); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); EXPECT_CALL(mock_event_listener_, - OnExpirationUpdate(_, kLicenseStartTime + kHighDuration)); + OnExpirationUpdate(_, kLicenseStartTime + kRentalDuration)); EXPECT_CALL(mock_event_listener_, - OnExpirationUpdate(_, NEVER_EXPIRES)); + OnExpirationUpdate(_, kLicenseStartTime + kLicenseDuration)); EXPECT_CALL(check_, Call(1)); - EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)); EXPECT_CALL(check_, Call(2)); - EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)); EXPECT_CALL(check_, Call(3)); + ExpectSessionKeysChange(kKeyStatusExpired, false); EXPECT_CALL(check_, Call(4)); policy_engine_->SetLicense(license_); @@ -476,41 +464,33 @@ TEST_F(PolicyEngineTest, PlaybackOk_PlaybackDuration0) { check_.Call(i); } - EXPECT_TRUE(policy_engine_->CanDecrypt(kKeyId)); + EXPECT_FALSE(policy_engine_->CanDecrypt(kKeyId)); } TEST_F(PolicyEngineTest, PlaybackOk_LicenseDuration0) { License_Policy* policy = license_.mutable_policy(); policy->set_license_duration_seconds(kDurationUnlimited); - policy->set_rental_duration_seconds(kLowDuration); - int64_t license_renewal_delay = GetLicenseRenewalDelay(kLowDuration); - policy->set_renewal_delay_seconds(license_renewal_delay); - int64_t min_duration = GetMinOfRentalPlaybackLicenseDurations(); EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime + 1)) .WillOnce(Return(kPlaybackStartTime)) - .WillOnce(Return(kLicenseStartTime + license_renewal_delay - 1)) - .WillOnce(Return(kLicenseStartTime + min_duration - 1)) - .WillOnce(Return(kLicenseStartTime + kPlaybackStartTime + - kPlaybackDuration)); + .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration - 1)) + .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 1)); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); EXPECT_CALL(mock_event_listener_, - OnExpirationUpdate(_, kLicenseStartTime + kLowDuration)); + OnExpirationUpdate(_, kLicenseStartTime + kRentalDuration)); EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, kPlaybackStartTime + kPlaybackDuration)); EXPECT_CALL(check_, Call(1)); - EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)); - EXPECT_CALL(check_, Call(2)); ExpectSessionKeysChange(kKeyStatusExpired, false); - EXPECT_CALL(check_, Call(3)); + EXPECT_CALL(check_, Call(2)); policy_engine_->SetLicense(license_); policy_engine_->BeginDecryption(); - for (int i = 1; i <= 3; ++i) { + for (int i = 1; i <= 2; ++i) { EXPECT_TRUE(policy_engine_->CanDecrypt(kKeyId)); policy_engine_->OnTimerEvent(); check_.Call(i); @@ -519,12 +499,34 @@ TEST_F(PolicyEngineTest, PlaybackOk_LicenseDuration0) { EXPECT_FALSE(policy_engine_->CanDecrypt(kKeyId)); } +TEST_F(PolicyEngineTest, PlaybackOk_PlaybackAndRental0) { + License_Policy* policy = license_.mutable_policy(); + policy->clear_rental_duration_seconds(); + policy->clear_playback_duration_seconds(); + // Only |license_duration_seconds| set. + + EXPECT_CALL(*mock_clock_, GetCurrentTime()) + .WillOnce(Return(kLicenseStartTime + 1)) + .WillOnce(Return(kPlaybackStartTime)) + .WillOnce(Return(kLicenseStartTime + 10)); + + ExpectSessionKeysChange(kKeyStatusUsable, true); + EXPECT_CALL(mock_event_listener_, + OnExpirationUpdate(_, kLicenseStartTime + kLicenseDuration)); + + policy_engine_->SetLicense(license_); + policy_engine_->BeginDecryption(); + policy_engine_->OnTimerEvent(); + + EXPECT_TRUE(policy_engine_->CanDecrypt(kKeyId)); + EXPECT_FALSE(policy_engine_->CanDecrypt(kSomeRandomKeyId)); +} + TEST_F(PolicyEngineTest, PlaybackOk_Durations0) { License_Policy* policy = license_.mutable_policy(); policy->set_rental_duration_seconds(kDurationUnlimited); policy->set_playback_duration_seconds(kDurationUnlimited); policy->set_license_duration_seconds(kDurationUnlimited); - policy->set_renewal_delay_seconds(kHighDuration + 10); EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime + 1)) @@ -556,7 +558,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_LicenseWithFutureStartTime) { InSequence s; ExpectSessionKeysChange(kKeyStatusPending, false); EXPECT_CALL(mock_event_listener_, - OnExpirationUpdate(_, kLicenseStartTime + kLowDuration)); + OnExpirationUpdate(_, kLicenseStartTime + kRentalDuration)); ExpectSessionKeysChange(kKeyStatusUsable, true); EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, kPlaybackStartTime + kPlaybackDuration)); @@ -575,22 +577,22 @@ TEST_F(PolicyEngineTest, PlaybackOk_LicenseWithFutureStartTime) { TEST_F(PolicyEngineTest, PlaybackFailed_CanRenewFalse) { License_Policy* policy = license_.mutable_policy(); + const int64_t license_renewal_delay = + GetLicenseRenewalDelay(kPlaybackDuration); + policy->set_renewal_delay_seconds(license_renewal_delay); policy->set_can_renew(false); - int64_t license_renewal_delay = - GetLicenseRenewalDelay(kStreamingLicenseDuration); EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime + 1)) .WillOnce(Return(kPlaybackStartTime)) .WillOnce(Return(kLicenseStartTime + license_renewal_delay - 10)) - .WillOnce(Return(kLicenseStartTime + kStreamingLicenseDuration + 10)) - .WillOnce(Return(kLicenseStartTime + kPlaybackStartTime + - kPlaybackDuration)); + .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration - 10)) + .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 1)); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); EXPECT_CALL(mock_event_listener_, - OnExpirationUpdate(_, kLicenseStartTime + kLowDuration)); + OnExpirationUpdate(_, kLicenseStartTime + kRentalDuration)); EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, kPlaybackStartTime + kPlaybackDuration)); EXPECT_CALL(check_, Call(1)); @@ -611,8 +613,11 @@ TEST_F(PolicyEngineTest, PlaybackFailed_CanRenewFalse) { } TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccess) { - int64_t license_renewal_delay = - GetLicenseRenewalDelay(kStreamingLicenseDuration); + License_Policy* policy = license_.mutable_policy(); + policy->set_can_renew(true); + policy->set_license_duration_seconds(kLowDuration); + int64_t license_renewal_delay = GetLicenseRenewalDelay(kLowDuration); + policy->set_renewal_delay_seconds(license_renewal_delay); int64_t new_license_start_time = kLicenseStartTime + license_renewal_delay + 15; @@ -629,11 +634,11 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccess) { ExpectSessionKeysChange(kKeyStatusUsable, true); EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, kLicenseStartTime + kLowDuration)); - EXPECT_CALL(mock_event_listener_, - OnExpirationUpdate(_, kPlaybackStartTime + kPlaybackDuration)); EXPECT_CALL(check_, Call(1)); EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)); EXPECT_CALL(check_, Call(2)); + EXPECT_CALL(mock_event_listener_, + OnExpirationUpdate(_, new_license_start_time + kLowDuration)); EXPECT_CALL(check_, Call(3)); policy_engine_->SetLicense(license_); @@ -648,6 +653,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccess) { EXPECT_TRUE(policy_engine_->CanDecrypt(kKeyId)); license_.set_license_start_time(new_license_start_time); + policy->set_playback_duration_seconds(2 * kPlaybackDuration); LicenseIdentification* id = license_.mutable_id(); id->set_version(2); policy_engine_->UpdateLicense(license_); @@ -659,8 +665,11 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccess) { } TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccess_WithFutureStartTime) { - int64_t license_renewal_delay = - GetLicenseRenewalDelay(kStreamingLicenseDuration); + License_Policy* policy = license_.mutable_policy(); + policy->set_can_renew(true); + policy->set_license_duration_seconds(kLowDuration); + int64_t license_renewal_delay = GetLicenseRenewalDelay(kLowDuration); + policy->set_renewal_delay_seconds(license_renewal_delay); int64_t new_license_start_time = kLicenseStartTime + license_renewal_delay + 50; @@ -677,12 +686,12 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccess_WithFutureStartTime) { ExpectSessionKeysChange(kKeyStatusUsable, true); EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, kLicenseStartTime + kLowDuration)); - EXPECT_CALL(mock_event_listener_, - OnExpirationUpdate(_, kPlaybackStartTime + kPlaybackDuration)); EXPECT_CALL(check_, Call(1)); EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)); EXPECT_CALL(check_, Call(2)); ExpectSessionKeysChange(kKeyStatusPending, false); + EXPECT_CALL(mock_event_listener_, + OnExpirationUpdate(_, new_license_start_time + kLowDuration)); EXPECT_CALL(check_, Call(3)); ExpectSessionKeysChange(kKeyStatusUsable, true); EXPECT_CALL(check_, Call(4)); @@ -712,15 +721,18 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccess_WithFutureStartTime) { } TEST_F(PolicyEngineTest, LicenseExpired_RenewFailedVersionNotUpdated) { - int64_t license_renewal_delay = - GetLicenseRenewalDelay(kStreamingLicenseDuration); + License_Policy* policy = license_.mutable_policy(); + policy->set_can_renew(true); + policy->set_license_duration_seconds(kLowDuration); + int64_t license_renewal_delay = GetLicenseRenewalDelay(kLowDuration); + policy->set_renewal_delay_seconds(license_renewal_delay); EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime + 1)) .WillOnce(Return(kLicenseStartTime + license_renewal_delay - 10)) .WillOnce(Return(kLicenseStartTime + license_renewal_delay + 10)) .WillOnce(Return(kLicenseStartTime + license_renewal_delay + 40)) - .WillOnce(Return(kLicenseStartTime + kStreamingLicenseDuration + 10)); + .WillOnce(Return(kLicenseStartTime + kLowDuration + 10)); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); @@ -760,8 +772,13 @@ TEST_F(PolicyEngineTest, LicenseExpired_RenewFailedVersionNotUpdated) { } TEST_F(PolicyEngineTest, PlaybackFailed_RepeatedRenewFailures) { - int64_t license_renewal_delay = - GetLicenseRenewalDelay(kStreamingLicenseDuration); + License_Policy* policy = license_.mutable_policy(); + policy->set_can_renew(true); + const int64_t license_renewal_delay = + GetLicenseRenewalDelay(kLicenseDuration); + policy->set_renewal_delay_seconds(license_renewal_delay); + policy->clear_rental_duration_seconds(); + policy->clear_playback_duration_seconds(); EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime + 1)) @@ -772,15 +789,13 @@ TEST_F(PolicyEngineTest, PlaybackFailed_RepeatedRenewFailures) { .WillOnce(Return(kLicenseStartTime + license_renewal_delay + 40)) .WillOnce(Return(kLicenseStartTime + license_renewal_delay + 50)) .WillOnce(Return(kLicenseStartTime + license_renewal_delay + 70)) - .WillOnce(Return(kLicenseStartTime + kStreamingLicenseDuration + 15)) - .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration)); + .WillOnce(Return(kLicenseStartTime + kLicenseDuration - 15)) + .WillOnce(Return(kLicenseStartTime + kLicenseDuration)); InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); EXPECT_CALL(mock_event_listener_, - OnExpirationUpdate(_, kLicenseStartTime + kLowDuration)); - EXPECT_CALL(mock_event_listener_, - OnExpirationUpdate(_, kPlaybackStartTime + kPlaybackDuration)); + OnExpirationUpdate(_, kLicenseStartTime + kLicenseDuration)); EXPECT_CALL(check_, Call(1)); EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)); EXPECT_CALL(check_, Call(2)); @@ -807,11 +822,16 @@ TEST_F(PolicyEngineTest, PlaybackFailed_RepeatedRenewFailures) { } TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccessAfterExpiry) { - int64_t license_renewal_delay = - GetLicenseRenewalDelay(kStreamingLicenseDuration); + License_Policy* policy = license_.mutable_policy(); + policy->set_can_renew(true); + policy->set_license_duration_seconds(kLowDuration); + int64_t license_renewal_delay = GetLicenseRenewalDelay(kLowDuration); + policy->set_renewal_delay_seconds(license_renewal_delay); + policy->clear_rental_duration_seconds(); + int64_t new_license_start_time = kPlaybackStartTime + kPlaybackDuration + 10; int64_t new_playback_duration = kPlaybackDuration + 100; - int64_t new_license_duration = kStreamingLicenseDuration + 100; + int64_t new_license_duration = kLicenseDuration + 100; EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime + 1)) @@ -823,8 +843,8 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccessAfterExpiry) { .WillOnce(Return(kLicenseStartTime + license_renewal_delay + 50)) .WillOnce(Return(kLicenseStartTime + license_renewal_delay + 70)) .WillOnce(Return(kLicenseStartTime + license_renewal_delay + 80)) - .WillOnce(Return(kLicenseStartTime + kStreamingLicenseDuration + 10)) - .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration)) + .WillOnce(Return(kLicenseStartTime + kLowDuration - 10)) + .WillOnce(Return(kLicenseStartTime + kLowDuration + 1)) .WillOnce(Return(new_license_start_time)) .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 20)); @@ -832,8 +852,6 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccessAfterExpiry) { ExpectSessionKeysChange(kKeyStatusUsable, true); EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, kLicenseStartTime + kLowDuration)); - EXPECT_CALL(mock_event_listener_, - OnExpirationUpdate(_, kPlaybackStartTime + kPlaybackDuration)); EXPECT_CALL(check_, Call(1)); EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)); EXPECT_CALL(check_, Call(2)); @@ -867,7 +885,6 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccessAfterExpiry) { license_.set_license_start_time(new_license_start_time); LicenseIdentification* id = license_.mutable_id(); id->set_version(2); - License_Policy* policy = license_.mutable_policy(); policy->set_playback_duration_seconds(new_playback_duration); policy->set_license_duration_seconds(new_license_duration); @@ -880,11 +897,14 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccessAfterExpiry) { } TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccessAfterFailures) { - int64_t license_renewal_delay = - GetLicenseRenewalDelay(kStreamingLicenseDuration); + License_Policy* policy = license_.mutable_policy(); + policy->set_can_renew(true); + policy->clear_rental_duration_seconds(); + policy->clear_playback_duration_seconds(); + int64_t license_renewal_delay = GetLicenseRenewalDelay(kLicenseDuration); + policy->set_renewal_delay_seconds(license_renewal_delay); int64_t new_license_start_time = kLicenseStartTime + license_renewal_delay + 55; - int64_t new_playback_duration = kPlaybackDuration + 100; EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime + 1)) @@ -901,9 +921,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccessAfterFailures) { InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); EXPECT_CALL(mock_event_listener_, - OnExpirationUpdate(_, kLicenseStartTime + kLowDuration)); - EXPECT_CALL(mock_event_listener_, - OnExpirationUpdate(_, kPlaybackStartTime + kPlaybackDuration)); + OnExpirationUpdate(_, kLicenseStartTime + kLicenseDuration)); EXPECT_CALL(check_, Call(1)); EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)); EXPECT_CALL(check_, Call(2)); @@ -911,9 +929,8 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccessAfterFailures) { EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)); EXPECT_CALL(check_, Call(4)); EXPECT_CALL(check_, Call(5)); - EXPECT_CALL( - mock_event_listener_, - OnExpirationUpdate(_, kPlaybackStartTime + new_playback_duration)); + EXPECT_CALL(mock_event_listener_, + OnExpirationUpdate(_, new_license_start_time + kLicenseDuration)); EXPECT_CALL(check_, Call(6)); EXPECT_CALL(check_, Call(7)); @@ -929,8 +946,6 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccessAfterFailures) { license_.set_license_start_time(new_license_start_time); LicenseIdentification* id = license_.mutable_id(); id->set_version(2); - license_.mutable_policy()->set_playback_duration_seconds( - new_playback_duration); policy_engine_->UpdateLicense(license_); for (int i = 6; i <= 7; ++i) { @@ -946,6 +961,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewedWithUsage) { int64_t new_playback_duration = kPlaybackDuration + 100; License_Policy* policy = license_.mutable_policy(); + policy->set_can_renew(true); policy->set_renew_with_usage(true); EXPECT_CALL(*mock_clock_, GetCurrentTime()) @@ -959,7 +975,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewedWithUsage) { InSequence s; ExpectSessionKeysChange(kKeyStatusUsable, true); EXPECT_CALL(mock_event_listener_, - OnExpirationUpdate(_, kLicenseStartTime + kLowDuration)); + OnExpirationUpdate(_, kLicenseStartTime + kRentalDuration)); EXPECT_CALL(check_, Call(1)); EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, kPlaybackStartTime + kPlaybackDuration)); @@ -1230,6 +1246,12 @@ class PolicyEngineQueryTest : public PolicyEngineTest { PolicyEngineTest::SetUp(); policy_engine_.reset(new PolicyEngine(kSessionId, NULL, NULL)); InjectMockClock(); + + // Use a STREAMING license policy. + License_Policy* policy = license_.mutable_policy(); + policy->set_license_duration_seconds(kLowDuration); + policy->set_can_renew(true); + policy->set_renewal_delay_seconds(GetLicenseRenewalDelay(kLowDuration)); } }; @@ -1269,15 +1291,10 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess) { EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]); - int64_t remaining_time; - std::istringstream ss; - ss.str(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]); - ss >> remaining_time; - ss.clear(); - EXPECT_EQ(kStreamingLicenseDuration - 100, remaining_time); - ss.str(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kPlaybackDuration, remaining_time); + EXPECT_EQ(kLowDuration - 100, + ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); + EXPECT_EQ(kPlaybackDuration, + ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); } @@ -1296,15 +1313,10 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackNotBegun) { EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]); - int64_t remaining_time; - std::istringstream ss; - ss.str(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kStreamingLicenseDuration - 100, remaining_time); - ss.clear(); - ss.str(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kPlaybackDuration, remaining_time); + EXPECT_EQ(kLowDuration - 100, + ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); + EXPECT_EQ(kPlaybackDuration, + ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); EXPECT_EQ(NO_ERROR, policy_engine_->Query(&query_info)); @@ -1313,14 +1325,10 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackNotBegun) { EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]); - ss.clear(); - ss.str(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kStreamingLicenseDuration - 200, remaining_time); - ss.clear(); - ss.str(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kPlaybackDuration, remaining_time); + EXPECT_EQ(kLowDuration - 200, + ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); + EXPECT_EQ(kPlaybackDuration, + ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); } @@ -1341,15 +1349,10 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackBegun) { EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]); - int64_t remaining_time; - std::istringstream ss; - ss.str(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kStreamingLicenseDuration - 50, remaining_time); - ss.clear(); - ss.str(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kPlaybackDuration, remaining_time); + EXPECT_EQ(kLowDuration - 50, + ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); + EXPECT_EQ(kPlaybackDuration, + ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); policy_engine_->BeginDecryption(); @@ -1363,14 +1366,10 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackBegun) { EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]); - ss.clear(); - ss.str(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kStreamingLicenseDuration - 200, remaining_time); - ss.clear(); - ss.str(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kPlaybackDuration - 100, remaining_time); + EXPECT_EQ(kLowDuration - 200, + ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); + EXPECT_EQ(kPlaybackDuration - 100, + ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); } @@ -1381,9 +1380,8 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_Offline) { License_Policy* policy = license_.mutable_policy(); policy->set_can_persist(true); policy->set_can_renew(false); - policy->set_license_duration_seconds(kOfflineLicenseDuration); - policy->set_renewal_delay_seconds( - GetLicenseRenewalDelay(kOfflineLicenseDuration)); + policy->set_rental_duration_seconds(kRentalDuration); + policy->set_license_duration_seconds(kLicenseDuration); EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime + 1)) @@ -1405,15 +1403,10 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_Offline) { EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_RENEW_ALLOWED]); - int64_t remaining_time; - std::istringstream ss; - ss.str(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kOfflineLicenseDuration - 300, remaining_time); - ss.clear(); - ss.str(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kPlaybackDuration - 100, remaining_time); + EXPECT_EQ(kRentalDuration - 300, + ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); + EXPECT_EQ(kPlaybackDuration - 100, + ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); } @@ -1437,22 +1430,16 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_InitialRentalDurationExpired) { EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]); - int64_t remaining_time; - std::istringstream ss; - ss.str(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(0, remaining_time); - ss.clear(); - ss.str(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kPlaybackDuration, remaining_time); + EXPECT_EQ(0, ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); + EXPECT_EQ(kPlaybackDuration, + ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); } TEST_F(PolicyEngineQueryTest, QuerySuccess_InitialLicenseDurationExpired) { EXPECT_CALL(*mock_clock_, GetCurrentTime()) - .WillOnce(Return(kLicenseStartTime + kStreamingLicenseDuration + 1)) - .WillOnce(Return(kLicenseStartTime + kStreamingLicenseDuration + 5)); + .WillOnce(Return(kLicenseStartTime + kLowDuration + 1)) + .WillOnce(Return(kLicenseStartTime + kLowDuration + 5)); policy_engine_->SetLicense(license_); @@ -1465,15 +1452,9 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_InitialLicenseDurationExpired) { EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]); - int64_t remaining_time; - std::istringstream ss; - ss.str(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(0, remaining_time); - ss.clear(); - ss.str(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kPlaybackDuration, remaining_time); + EXPECT_EQ(0, ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); + EXPECT_EQ(kPlaybackDuration, + ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); } @@ -1484,9 +1465,6 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_CanPlayFalse) { License_Policy* policy = license_.mutable_policy(); policy->set_can_play(false); policy->set_can_persist(true); - policy->set_license_duration_seconds(kOfflineLicenseDuration); - policy->set_renewal_delay_seconds( - GetLicenseRenewalDelay(kOfflineLicenseDuration)); EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime + 1)) @@ -1508,15 +1486,10 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_CanPlayFalse) { EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]); - int64_t remaining_time; - std::istringstream ss; - ss.str(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kOfflineLicenseDuration - 100, remaining_time); - ss.clear(); - ss.str(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kPlaybackDuration, remaining_time); + EXPECT_EQ(kLowDuration - 100, + ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); + EXPECT_EQ(kPlaybackDuration, + ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); } @@ -1526,13 +1499,12 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalDurationExpired) { policy->set_license_duration_seconds(kHighDuration); policy->set_renewal_delay_seconds(GetLicenseRenewalDelay(kHighDuration)); - int64_t min_duration = GetMinOfRentalPlaybackLicenseDurations(); EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime + 1)) .WillOnce(Return(kPlaybackStartTime)) - .WillOnce(Return(kLicenseStartTime + min_duration - 1)) - .WillOnce(Return(kLicenseStartTime + min_duration)) - .WillOnce(Return(kLicenseStartTime + min_duration + 5)); + .WillOnce(Return(kLicenseStartTime + kLowDuration - 1)) + .WillOnce(Return(kLicenseStartTime + kLowDuration)) + .WillOnce(Return(kLicenseStartTime + kLowDuration + 5)); policy_engine_->SetLicense(license_); @@ -1552,15 +1524,9 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalDurationExpired) { EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]); - int64_t remaining_time; - std::istringstream ss; - ss.str(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(0, remaining_time); - ss.clear(); - ss.str(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kPlaybackDuration - min_duration, remaining_time); + EXPECT_EQ(0, ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); + EXPECT_EQ(kPlaybackDuration - kLowDuration, + ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); } @@ -1570,14 +1536,13 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDurationExpired) { policy->set_license_duration_seconds(kHighDuration); policy->set_renewal_delay_seconds(GetLicenseRenewalDelay(kHighDuration)); - int64_t min_duration = GetMinOfRentalPlaybackLicenseDurations(); int64_t playback_start_time = kLicenseStartTime + 10000; EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime + 1)) .WillOnce(Return(playback_start_time)) - .WillOnce(Return(playback_start_time - 2 + min_duration)) - .WillOnce(Return(playback_start_time + 2 + min_duration)) - .WillOnce(Return(playback_start_time + 5 + min_duration)); + .WillOnce(Return(playback_start_time - 2 + kLowDuration)) + .WillOnce(Return(playback_start_time + 2 + kLowDuration)) + .WillOnce(Return(playback_start_time + 5 + kLowDuration)); policy_engine_->SetLicense(license_); @@ -1597,29 +1562,21 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDurationExpired) { EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]); - int64_t remaining_time; - std::istringstream ss; - ss.str(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kHighDuration - 10005 - min_duration, remaining_time); - ss.clear(); - ss.str(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(0, remaining_time); + EXPECT_EQ(0, ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); + EXPECT_EQ(0, ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); } TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseDurationExpired) { License_Policy* policy = license_.mutable_policy(); policy->set_can_renew(false); - int64_t min_duration = GetMinOfRentalPlaybackLicenseDurations(); EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime + 1)) - .WillOnce(Return(kLicenseStartTime + 5)) - .WillOnce(Return(kLicenseStartTime + min_duration - 1)) - .WillOnce(Return(kLicenseStartTime + min_duration)) - .WillOnce(Return(kLicenseStartTime + min_duration + 5)); + .WillOnce(Return(kPlaybackStartTime)) + .WillOnce(Return(kLicenseStartTime + kLowDuration - 1)) + .WillOnce(Return(kLicenseStartTime + kLowDuration)) + .WillOnce(Return(kLicenseStartTime + kLowDuration + 5)); policy_engine_->SetLicense(license_); @@ -1630,7 +1587,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseDurationExpired) { policy_engine_->OnTimerEvent(); } - EXPECT_TRUE(policy_engine_->CanDecrypt(kKeyId)); + EXPECT_FALSE(policy_engine_->CanDecrypt(kKeyId)); CdmQueryMap query_info; EXPECT_EQ(NO_ERROR, policy_engine_->Query(&query_info)); @@ -1639,32 +1596,25 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseDurationExpired) { EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_RENEW_ALLOWED]); - int64_t remaining_time; - std::istringstream ss; - ss.str(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(0, remaining_time); - ss.clear(); - ss.str(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kPlaybackDuration - min_duration, remaining_time); + EXPECT_EQ(0, ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); + EXPECT_EQ(kPlaybackDuration - kLowDuration, + ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); } TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalDuration0) { License_Policy* policy = license_.mutable_policy(); policy->set_rental_duration_seconds(kDurationUnlimited); - int64_t license_renewal_delay = - GetLicenseRenewalDelay(kStreamingLicenseDuration); + int64_t license_renewal_delay = GetLicenseRenewalDelay(kLowDuration); EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime + 1)) .WillOnce(Return(kLicenseStartTime + 5)) .WillOnce(Return(kLicenseStartTime + license_renewal_delay - 1)) .WillOnce(Return(kLicenseStartTime + license_renewal_delay)) - .WillOnce(Return(kLicenseStartTime + kStreamingLicenseDuration - 1)) - .WillOnce(Return(kLicenseStartTime + kStreamingLicenseDuration)) - .WillOnce(Return(kLicenseStartTime + kStreamingLicenseDuration + 5)); + .WillOnce(Return(kLicenseStartTime + kLowDuration - 1)) + .WillOnce(Return(kLicenseStartTime + kLowDuration)) + .WillOnce(Return(kLicenseStartTime + kLowDuration + 5)); policy_engine_->SetLicense(license_); @@ -1675,7 +1625,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalDuration0) { policy_engine_->OnTimerEvent(); } - EXPECT_TRUE(policy_engine_->CanDecrypt(kKeyId)); + EXPECT_FALSE(policy_engine_->CanDecrypt(kKeyId)); CdmQueryMap query_info; EXPECT_EQ(NO_ERROR, policy_engine_->Query(&query_info)); @@ -1684,15 +1634,9 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalDuration0) { EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]); - int64_t remaining_time; - std::istringstream ss; - ss.str(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(0, remaining_time); - ss.clear(); - ss.str(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kPlaybackDuration - kStreamingLicenseDuration, remaining_time); + EXPECT_EQ(0, ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); + EXPECT_EQ(kPlaybackDuration - kLowDuration, + ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); } @@ -1729,22 +1673,17 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDuration0) { EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]); - int64_t remaining_time; - std::istringstream ss; - ss.str(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kHighDuration - license_renewal_delay - 5, remaining_time); - ss.clear(); - ss.str(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(LLONG_MAX, remaining_time); + EXPECT_EQ(0, + ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); + EXPECT_EQ(LLONG_MAX, + ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); for (int i = 3; i <= 4; ++i) { policy_engine_->OnTimerEvent(); } - EXPECT_TRUE(policy_engine_->CanDecrypt(kKeyId)); + EXPECT_FALSE(policy_engine_->CanDecrypt(kKeyId)); EXPECT_EQ(NO_ERROR, policy_engine_->Query(&query_info)); EXPECT_EQ(QUERY_VALUE_STREAMING, query_info[QUERY_KEY_LICENSE_TYPE]); @@ -1752,30 +1691,23 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDuration0) { EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]); - ss.clear(); - ss.str(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(0, remaining_time); - ss.clear(); - ss.str(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(LLONG_MAX, remaining_time); + EXPECT_EQ(0, + ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); + EXPECT_EQ(LLONG_MAX, + ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); } TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseDuration0) { License_Policy* policy = license_.mutable_policy(); policy->set_license_duration_seconds(kDurationUnlimited); - policy->set_rental_duration_seconds(kStreamingLicenseDuration); - policy->set_renewal_delay_seconds(GetLicenseRenewalDelay(kHighDuration)); - int64_t min_duration = GetMinOfRentalPlaybackLicenseDurations(); EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime + 1)) - .WillOnce(Return(kLicenseStartTime + 5)) - .WillOnce(Return(kLicenseStartTime + min_duration - 1)) - .WillOnce(Return(kLicenseStartTime + min_duration)) - .WillOnce(Return(kLicenseStartTime + min_duration + 5)); + .WillOnce(Return(kPlaybackStartTime)) + .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration - 1)) + .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration)) + .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 5)); policy_engine_->SetLicense(license_); @@ -1786,7 +1718,7 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseDuration0) { policy_engine_->OnTimerEvent(); } - EXPECT_TRUE(policy_engine_->CanDecrypt(kKeyId)); + EXPECT_FALSE(policy_engine_->CanDecrypt(kKeyId)); CdmQueryMap query_info; EXPECT_EQ(NO_ERROR, policy_engine_->Query(&query_info)); @@ -1795,15 +1727,8 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseDuration0) { EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]); - int64_t remaining_time; - std::istringstream ss; - ss.str(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(0, remaining_time); - ss.clear(); - ss.str(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kPlaybackDuration - min_duration, remaining_time); + EXPECT_EQ(0, ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); + EXPECT_EQ(0, ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); } @@ -1838,15 +1763,10 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_Durations0) { EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]); - int64_t remaining_time; - std::istringstream ss; - ss.str(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(LLONG_MAX, remaining_time); - ss.clear(); - ss.str(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(LLONG_MAX, remaining_time); + EXPECT_EQ(LLONG_MAX, + ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); + EXPECT_EQ(LLONG_MAX, + ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); } @@ -1871,15 +1791,10 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseWithFutureStartTime) { EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]); - int64_t remaining_time; - std::istringstream ss; - ss.str(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kStreamingLicenseDuration, remaining_time); - ss.clear(); - ss.str(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kPlaybackDuration, remaining_time); + EXPECT_EQ(kLowDuration, + ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); + EXPECT_EQ(kPlaybackDuration, + ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); EXPECT_FALSE(policy_engine_->CanDecrypt(kKeyId)); @@ -1894,20 +1809,15 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseWithFutureStartTime) { EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]); - ss.clear(); - ss.str(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kStreamingLicenseDuration - 25, remaining_time); - ss.clear(); - ss.str(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kPlaybackDuration - 15, remaining_time); + EXPECT_EQ(kLowDuration - 25, + ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); + EXPECT_EQ(kPlaybackDuration - 15, + ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); } TEST_F(PolicyEngineQueryTest, QuerySuccess_Renew) { - int64_t license_renewal_delay = - GetLicenseRenewalDelay(kStreamingLicenseDuration); + int64_t license_renewal_delay = license_.policy().renewal_delay_seconds(); EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime + 1)) @@ -1947,24 +1857,16 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_Renew) { EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]); - int64_t remaining_time; - std::istringstream ss; - ss.str(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kStreamingLicenseDuration - kLicenseRenewalRetryInterval, - remaining_time); - ss.clear(); - ss.str(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]); - ss >> remaining_time; + EXPECT_EQ(kLowDuration - kLicenseRenewalRetryInterval, + ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); EXPECT_EQ(kPlaybackDuration + 5 - license_renewal_delay - kLicenseRenewalRetryInterval - 15, - remaining_time); + ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); } TEST_F(PolicyEngineQueryTest, QuerySuccess_RenewWithFutureStartTime) { - int64_t license_renewal_delay = - GetLicenseRenewalDelay(kStreamingLicenseDuration); + int64_t license_renewal_delay = license_.policy().renewal_delay_seconds(); EXPECT_CALL(*mock_clock_, GetCurrentTime()) .WillOnce(Return(kLicenseStartTime + 1)) @@ -2008,17 +1910,11 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_RenewWithFutureStartTime) { EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]); - int64_t remaining_time; - std::istringstream ss; - ss.str(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kStreamingLicenseDuration, remaining_time); - ss.clear(); - ss.str(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]); - ss >> remaining_time; + EXPECT_EQ(kLowDuration, + ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); EXPECT_EQ(kPlaybackDuration + 5 - license_renewal_delay - kLicenseRenewalRetryInterval - 20, - remaining_time); + ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); policy_engine_->OnTimerEvent(); @@ -2030,16 +1926,11 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_RenewWithFutureStartTime) { EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]); EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]); - ss.clear(); - ss.str(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]); - ss >> remaining_time; - EXPECT_EQ(kStreamingLicenseDuration - 20, remaining_time); - ss.clear(); - ss.str(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]); - ss >> remaining_time; + EXPECT_EQ(kLowDuration - 20, + ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING])); EXPECT_EQ(kPlaybackDuration + 5 - license_renewal_delay - kLicenseRenewalRetryInterval - 40, - remaining_time); + ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING])); EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]); } @@ -2049,7 +1940,7 @@ TEST_F(PolicyEngineTest, SetLicenseForRelease) { // No key change event will fire. EXPECT_CALL(mock_event_listener_, - OnExpirationUpdate(_, kLicenseStartTime + kLowDuration)); + OnExpirationUpdate(_, kLicenseStartTime + kRentalDuration)); policy_engine_->SetLicenseForRelease(license_); // No keys were loaded. EXPECT_FALSE(policy_engine_->CanDecrypt(kKeyId)); @@ -2063,7 +1954,7 @@ TEST_F(PolicyEngineTest, SetLicenseForReleaseAfterSetLicense) { ExpectSessionKeysChange(kKeyStatusUsable, true); EXPECT_CALL(mock_event_listener_, - OnExpirationUpdate(_, kLicenseStartTime + kLowDuration)); + OnExpirationUpdate(_, kLicenseStartTime + kRentalDuration)); EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, kPlaybackStartTime + kPlaybackDuration));