Source release v3.5.0

2017-11-28 17:42:16 -08:00
parent 501c22890d
commit 31381a1311
155 changed files with 16680 additions and 3816 deletions
--- a/core/test/policy_engine_unittest.cpp
+++ b/core/test/policy_engine_unittest.cpp
@@ -56,7 +56,14 @@ int64_t ParseInt(const std::string& str) {

 class HdcpOnlyMockCryptoSession : public CryptoSession {
 public:
+  HdcpOnlyMockCryptoSession(metrics::CryptoMetrics* metrics) :
+      CryptoSession(metrics) {}
+
  MOCK_METHOD2(GetHdcpCapabilities, bool(HdcpCapability*, HdcpCapability*));
+  bool DoRealGetHdcpCapabilities(HdcpCapability* current,
+                                 HdcpCapability* max) {
+    return CryptoSession::GetHdcpCapabilities(current, max);
+  }
 };

 class MockCdmEventListener : public WvCdmEventListener {
@@ -82,6 +89,7 @@ using video_widevine::OFFLINE;
 using ::testing::_;
 using ::testing::AtLeast;
 using ::testing::InSequence;
+using ::testing::Invoke;
 using ::testing::MockFunction;
 using ::testing::Pair;
 using ::testing::Return;
@@ -89,6 +97,9 @@ using ::testing::StrictMock;
 using ::testing::UnorderedElementsAre;

 class PolicyEngineTest : public ::testing::Test {
+ public:
+  PolicyEngineTest() : crypto_session_(&dummy_metrics_) {
+  }
 protected:
  virtual void SetUp() {
    policy_engine_.reset(
@@ -122,6 +133,12 @@ class PolicyEngineTest : public ::testing::Test {
    policy->set_renewal_delay_seconds(0);
    policy->set_renewal_retry_interval_seconds(kLicenseRenewalRetryInterval);
    policy->set_renew_with_usage(false);
+
+    ON_CALL(crypto_session_, GetHdcpCapabilities(_, _))
+      .WillByDefault(
+          Invoke(
+              &crypto_session_,
+              &HdcpOnlyMockCryptoSession::DoRealGetHdcpCapabilities));
  }

  void InjectMockClock() {
@@ -149,7 +166,8 @@ class PolicyEngineTest : public ::testing::Test {
                    expected_has_new_usable_key));
  }

-  StrictMock<HdcpOnlyMockCryptoSession> crypto_session_;
+  metrics::CryptoMetrics dummy_metrics_;
+  NiceMock<HdcpOnlyMockCryptoSession> crypto_session_;
  StrictMock<MockCdmEventListener> mock_event_listener_;
  MockClock* mock_clock_;
  scoped_ptr<PolicyEngine> policy_engine_;
@@ -596,6 +614,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);
@@ -2185,6 +2325,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);