From be9aba6d3ad2f67ef7d5ad64c6530d632f371d82 Mon Sep 17 00:00:00 2001
From: Rahul Frias <rfrias@google.com>
Date: Fri, 22 Sep 2017 13:27:10 -0700
Subject: [PATCH] Corrections to license duration reporting

[ Merge of http://go/wvgerrit/34900 ]

Querying information about licenses with uncommon duration values
did not, under all conditions, return expected values. This corrects
for licenses where
* playback and license durations were set to unlimited
* rental and license durations were set to unlimited

Bug: 65669869

Test: 9 new policy_engine_unittests
Test: WV unit/integration tests
Test: GTSMediaTestCases
Test: Playback using netflix and play movies
Change-Id: I6e48f82f1f194fb7e04491d33054dfe74d9465eb
---
 libwvdrmengine/cdm/core/src/policy_engine.cpp |   2 +
 .../cdm/core/test/policy_engine_unittest.cpp  | 419 ++++++++++++++++++
 2 files changed, 421 insertions(+)

diff --git a/libwvdrmengine/cdm/core/src/policy_engine.cpp b/libwvdrmengine/cdm/core/src/policy_engine.cpp
index b1d2d846..b6f52058 100644
--- a/libwvdrmengine/cdm/core/src/policy_engine.cpp
+++ b/libwvdrmengine/cdm/core/src/policy_engine.cpp
@@ -403,6 +403,8 @@ int64_t PolicyEngine::GetLicenseOrRentalDurationRemaining(
   if (license_expiry_time == NEVER_EXPIRES) return LLONG_MAX;
   if (license_expiry_time < current_time) return 0;
   const int64_t policy_license_duration = policy_.license_duration_seconds();
+  if (policy_license_duration == NEVER_EXPIRES)
+    return license_expiry_time - current_time;
   return std::min(license_expiry_time - current_time, policy_license_duration);
 }
 
diff --git a/libwvdrmengine/cdm/core/test/policy_engine_unittest.cpp b/libwvdrmengine/cdm/core/test/policy_engine_unittest.cpp
index 23b7f3d4..41523a85 100644
--- a/libwvdrmengine/cdm/core/test/policy_engine_unittest.cpp
+++ b/libwvdrmengine/cdm/core/test/policy_engine_unittest.cpp
@@ -522,6 +522,128 @@ TEST_F(PolicyEngineTest, PlaybackOk_PlaybackAndRental0) {
   EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
 }
 
+TEST_F(PolicyEngineTest, PlaybackOk_PlaybackAndLicense0_WithoutPlayback) {
+  License_Policy* policy = license_.mutable_policy();
+  policy->clear_license_duration_seconds();
+  policy->clear_playback_duration_seconds();
+  // Only |rental_duration_seconds| set.
+
+  EXPECT_CALL(*mock_clock_, GetCurrentTime())
+      .WillOnce(Return(kLicenseStartTime + 1))
+      .WillOnce(Return(kLicenseStartTime + 10))
+      .WillOnce(Return(kLicenseStartTime + kRentalDuration - 10))
+      .WillOnce(Return(kLicenseStartTime + kRentalDuration + 10));
+
+  ExpectSessionKeysChange(kKeyStatusExpired, false);
+  ExpectSessionKeysChange(kKeyStatusUsable, true);
+  EXPECT_CALL(mock_event_listener_,
+              OnExpirationUpdate(_, kLicenseStartTime + kRentalDuration));
+
+  policy_engine_->SetLicense(license_);
+  policy_engine_->OnTimerEvent();
+
+  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
+
+  policy_engine_->OnTimerEvent();
+
+  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
+
+  policy_engine_->OnTimerEvent();
+
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
+}
+
+TEST_F(PolicyEngineTest, PlaybackOk_PlaybackAndLicense0_WithPlayback) {
+  License_Policy* policy = license_.mutable_policy();
+  policy->clear_license_duration_seconds();
+  policy->clear_playback_duration_seconds();
+  // Only |rental_duration_seconds| set.
+
+  EXPECT_CALL(*mock_clock_, GetCurrentTime())
+      .WillOnce(Return(kLicenseStartTime + 1))
+      .WillOnce(Return(kPlaybackStartTime))
+      .WillOnce(Return(kLicenseStartTime + 10))
+      .WillOnce(Return(kLicenseStartTime + kRentalDuration + 10));
+
+  ExpectSessionKeysChange(kKeyStatusUsable, true);
+  EXPECT_CALL(mock_event_listener_,
+              OnExpirationUpdate(_, 0));
+  EXPECT_CALL(mock_event_listener_,
+              OnExpirationUpdate(_, kLicenseStartTime + kRentalDuration));
+
+  policy_engine_->SetLicense(license_);
+  policy_engine_->BeginDecryption();
+  policy_engine_->OnTimerEvent();
+
+  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
+
+  policy_engine_->OnTimerEvent();
+
+  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
+}
+
+TEST_F(PolicyEngineTest, PlaybackOk_RentalAndLicense0_WithoutPlayback) {
+  License_Policy* policy = license_.mutable_policy();
+  policy->clear_license_duration_seconds();
+  policy->clear_rental_duration_seconds();
+  // Only |playback_duration_seconds| set.
+
+  EXPECT_CALL(*mock_clock_, GetCurrentTime())
+      .WillOnce(Return(kLicenseStartTime + 1))
+      .WillOnce(Return(kLicenseStartTime + 10))
+      .WillOnce(Return(kLicenseStartTime + kPlaybackDuration + 10));
+
+  ExpectSessionKeysChange(kKeyStatusUsable, true);
+  EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, 0));
+
+  policy_engine_->SetLicense(license_);
+  policy_engine_->OnTimerEvent();
+
+  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
+
+  policy_engine_->OnTimerEvent();
+
+  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
+}
+
+TEST_F(PolicyEngineTest, PlaybackOk_RentalAndLicense0_WithPlayback) {
+  License_Policy* policy = license_.mutable_policy();
+  policy->clear_license_duration_seconds();
+  policy->clear_rental_duration_seconds();
+  // Only |playback_duration_seconds| set.
+
+  EXPECT_CALL(*mock_clock_, GetCurrentTime())
+      .WillOnce(Return(kLicenseStartTime + 1))
+      .WillOnce(Return(kPlaybackStartTime))
+      .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration - 10))
+      .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 10));
+
+  ExpectSessionKeysChange(kKeyStatusExpired, false);
+  ExpectSessionKeysChange(kKeyStatusUsable, true);
+  EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, 0));
+  EXPECT_CALL(mock_event_listener_,
+              OnExpirationUpdate(_, kPlaybackStartTime + kPlaybackDuration));
+
+  policy_engine_->SetLicense(license_);
+  policy_engine_->BeginDecryption();
+  policy_engine_->OnTimerEvent();
+
+  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
+
+  policy_engine_->OnTimerEvent();
+
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
+}
+
 TEST_F(PolicyEngineTest, PlaybackOk_Durations0) {
   License_Policy* policy = license_.mutable_policy();
   policy->set_rental_duration_seconds(kDurationUnlimited);
@@ -1951,6 +2073,303 @@ TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseDuration0) {
   EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
 }
 
+TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackAndRental0) {
+  License_Policy* policy = license_.mutable_policy();
+  policy->set_rental_duration_seconds(kDurationUnlimited);
+  policy->set_playback_duration_seconds(kDurationUnlimited);
+  policy->set_license_duration_seconds(kLowDuration);
+  // Only |license_duration_seconds| set.
+
+  EXPECT_CALL(*mock_clock_, GetCurrentTime())
+      .WillOnce(Return(kLicenseStartTime + 1))
+      .WillOnce(Return(kPlaybackStartTime))
+      .WillOnce(Return(kLicenseStartTime + 10))
+      .WillOnce(Return(kLicenseStartTime + kLowDuration - 10))
+      .WillOnce(Return(kLicenseStartTime + kLowDuration + 10))
+      .WillOnce(Return(kLicenseStartTime + kLowDuration + 10));
+
+  policy_engine_->SetLicense(license_);
+  policy_engine_->BeginDecryption();
+  policy_engine_->OnTimerEvent();
+
+  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
+
+  CdmQueryMap query_info;
+  EXPECT_EQ(NO_ERROR, policy_engine_->Query(&query_info));
+  EXPECT_EQ(QUERY_VALUE_STREAMING, query_info[QUERY_KEY_LICENSE_TYPE]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_PLAY_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]);
+
+  EXPECT_EQ(10, 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]);
+
+  policy_engine_->OnTimerEvent();
+
+  EXPECT_EQ(NO_ERROR, policy_engine_->Query(&query_info));
+  EXPECT_EQ(QUERY_VALUE_STREAMING, query_info[QUERY_KEY_LICENSE_TYPE]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_PLAY_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]);
+
+  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_PlaybackAndLicense0_WithoutPlayback) {
+  License_Policy* policy = license_.mutable_policy();
+  policy->set_rental_duration_seconds(kRentalDuration);
+  policy->set_playback_duration_seconds(kDurationUnlimited);
+  policy->set_license_duration_seconds(kDurationUnlimited);
+  // Only |rental_duration_seconds| set.
+
+  EXPECT_CALL(*mock_clock_, GetCurrentTime())
+      .WillOnce(Return(kLicenseStartTime + 1))
+      .WillOnce(Return(kLicenseStartTime + 10))
+      .WillOnce(Return(kLicenseStartTime + kRentalDuration - 10))
+      .WillOnce(Return(kLicenseStartTime + kRentalDuration - 10))
+      .WillOnce(Return(kLicenseStartTime + kRentalDuration + 10))
+      .WillOnce(Return(kLicenseStartTime + kRentalDuration + 10));
+
+  policy_engine_->SetLicense(license_);
+  policy_engine_->OnTimerEvent();
+
+  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
+
+  policy_engine_->OnTimerEvent();
+
+  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
+
+  CdmQueryMap query_info;
+  EXPECT_EQ(NO_ERROR, policy_engine_->Query(&query_info));
+  EXPECT_EQ(QUERY_VALUE_STREAMING, query_info[QUERY_KEY_LICENSE_TYPE]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_PLAY_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]);
+
+  EXPECT_EQ(10, 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]);
+
+  policy_engine_->OnTimerEvent();
+
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
+
+  EXPECT_EQ(NO_ERROR, policy_engine_->Query(&query_info));
+  EXPECT_EQ(QUERY_VALUE_STREAMING, query_info[QUERY_KEY_LICENSE_TYPE]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_PLAY_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]);
+
+  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_PlaybackAndLicense0_WithPlayback) {
+  License_Policy* policy = license_.mutable_policy();
+  policy->set_rental_duration_seconds(kRentalDuration);
+  policy->set_playback_duration_seconds(kDurationUnlimited);
+  policy->set_license_duration_seconds(kDurationUnlimited);
+  // Only |rental_duration_seconds| set.
+
+  EXPECT_CALL(*mock_clock_, GetCurrentTime())
+      .WillOnce(Return(kLicenseStartTime + 1))
+      .WillOnce(Return(kPlaybackStartTime))
+      .WillOnce(Return(kLicenseStartTime + kPlaybackDuration - 10))
+      .WillOnce(Return(kLicenseStartTime + kPlaybackDuration - 10))
+      .WillOnce(Return(kLicenseStartTime + kPlaybackDuration + 10))
+      .WillOnce(Return(kLicenseStartTime + kPlaybackDuration + 10))
+      .WillOnce(Return(kLicenseStartTime + kRentalDuration + 10))
+      .WillOnce(Return(kLicenseStartTime + kRentalDuration + 10));
+
+  policy_engine_->SetLicense(license_);
+  policy_engine_->BeginDecryption();
+  policy_engine_->OnTimerEvent();
+
+  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
+
+  CdmQueryMap query_info;
+  EXPECT_EQ(NO_ERROR, policy_engine_->Query(&query_info));
+  EXPECT_EQ(QUERY_VALUE_STREAMING, query_info[QUERY_KEY_LICENSE_TYPE]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_PLAY_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]);
+
+  EXPECT_EQ(kRentalDuration - kPlaybackDuration + 10,
+            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]);
+
+  policy_engine_->OnTimerEvent();
+
+  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
+
+  EXPECT_EQ(NO_ERROR, policy_engine_->Query(&query_info));
+  EXPECT_EQ(QUERY_VALUE_STREAMING, query_info[QUERY_KEY_LICENSE_TYPE]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_PLAY_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]);
+
+  EXPECT_EQ(kRentalDuration - kPlaybackDuration - 10,
+            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]);
+
+  policy_engine_->OnTimerEvent();
+
+  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
+
+  EXPECT_EQ(NO_ERROR, policy_engine_->Query(&query_info));
+  EXPECT_EQ(QUERY_VALUE_STREAMING, query_info[QUERY_KEY_LICENSE_TYPE]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_PLAY_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]);
+
+  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_RentalAndLicense0_WithoutPlayback) {
+  License_Policy* policy = license_.mutable_policy();
+  policy->set_rental_duration_seconds(kDurationUnlimited);
+  policy->set_playback_duration_seconds(kPlaybackDuration);
+  policy->set_license_duration_seconds(kDurationUnlimited);
+  // Only |playback_duration_seconds| set.
+
+  EXPECT_CALL(*mock_clock_, GetCurrentTime())
+      .WillOnce(Return(kLicenseStartTime + 1))
+      .WillOnce(Return(kLicenseStartTime + 10))
+      .WillOnce(Return(kLicenseStartTime + 10))
+      .WillOnce(Return(kLicenseStartTime + kPlaybackDuration + 10))
+      .WillOnce(Return(kLicenseStartTime + kPlaybackDuration + 10));
+
+  policy_engine_->SetLicense(license_);
+  policy_engine_->OnTimerEvent();
+
+  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
+
+  CdmQueryMap query_info;
+  EXPECT_EQ(NO_ERROR, policy_engine_->Query(&query_info));
+  EXPECT_EQ(QUERY_VALUE_STREAMING, query_info[QUERY_KEY_LICENSE_TYPE]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_PLAY_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]);
+
+  EXPECT_EQ(LLONG_MAX,
+            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_->OnTimerEvent();
+
+  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
+
+  EXPECT_EQ(NO_ERROR, policy_engine_->Query(&query_info));
+  EXPECT_EQ(QUERY_VALUE_STREAMING, query_info[QUERY_KEY_LICENSE_TYPE]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_PLAY_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]);
+
+  EXPECT_EQ(LLONG_MAX,
+            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_RentalAndLicense0_WithPlayback) {
+  License_Policy* policy = license_.mutable_policy();
+  policy->set_rental_duration_seconds(kDurationUnlimited);
+  policy->set_playback_duration_seconds(kPlaybackDuration);
+  policy->set_license_duration_seconds(kDurationUnlimited);
+  // Only |playback_duration_seconds| set.
+
+  EXPECT_CALL(*mock_clock_, GetCurrentTime())
+      .WillOnce(Return(kLicenseStartTime + 1))
+      .WillOnce(Return(kPlaybackStartTime))
+      .WillOnce(Return(kPlaybackStartTime + 10))
+      .WillOnce(Return(kPlaybackStartTime + 10))
+      .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration - 10))
+      .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration - 10))
+      .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 10))
+      .WillOnce(Return(kPlaybackStartTime + kPlaybackDuration + 10));
+
+  policy_engine_->SetLicense(license_);
+  policy_engine_->BeginDecryption();
+  policy_engine_->OnTimerEvent();
+
+  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
+
+  CdmQueryMap query_info;
+  EXPECT_EQ(NO_ERROR, policy_engine_->Query(&query_info));
+  EXPECT_EQ(QUERY_VALUE_STREAMING, query_info[QUERY_KEY_LICENSE_TYPE]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_PLAY_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]);
+
+  EXPECT_EQ(LLONG_MAX,
+            ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]));
+  EXPECT_EQ(kPlaybackDuration - 10,
+            ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]));
+  EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
+
+  policy_engine_->OnTimerEvent();
+
+  EXPECT_TRUE(policy_engine_->CanDecryptContent(kKeyId));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
+
+  EXPECT_EQ(NO_ERROR, policy_engine_->Query(&query_info));
+  EXPECT_EQ(QUERY_VALUE_STREAMING, query_info[QUERY_KEY_LICENSE_TYPE]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_PLAY_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]);
+
+  EXPECT_EQ(LLONG_MAX,
+            ParseInt(query_info[QUERY_KEY_LICENSE_DURATION_REMAINING]));
+  EXPECT_EQ(10,
+            ParseInt(query_info[QUERY_KEY_PLAYBACK_DURATION_REMAINING]));
+  EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
+
+  policy_engine_->OnTimerEvent();
+
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kKeyId));
+  EXPECT_FALSE(policy_engine_->CanDecryptContent(kSomeRandomKeyId));
+
+  EXPECT_EQ(NO_ERROR, policy_engine_->Query(&query_info));
+  EXPECT_EQ(QUERY_VALUE_STREAMING, query_info[QUERY_KEY_LICENSE_TYPE]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_PLAY_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_FALSE, query_info[QUERY_KEY_PERSIST_ALLOWED]);
+  EXPECT_EQ(QUERY_VALUE_TRUE, query_info[QUERY_KEY_RENEW_ALLOWED]);
+
+  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_Durations0) {
   License_Policy* policy = license_.mutable_policy();
   policy->set_rental_duration_seconds(kDurationUnlimited);