Report change in session expiration

Bug: 19771612

Merged from Widevine CDM repo:
https://widevine-internal-review.googlesource.com/#/c/13885/

Change-Id: I754f06a7ed9476554f9e1da3fe23f4563f9fc07e

libwvdrmengine/cdm/core/include/policy_engine.h

@@ -63,8 +63,12 @@ class PolicyEngine {
 
   virtual const LicenseIdentification& license_id() { return license_id_; }
 
-  bool IsLicenseDurationExpired(int64_t current_time);
-  bool IsPlaybackDurationExpired(int64_t current_time);
+  bool IsLicenseDurationExpired(int64_t current_time) {
+    return GetLicenseExpiryTime() <= current_time;
+  }
+  bool IsPlaybackDurationExpired(int64_t current_time) {
+    return GetPlaybackExpiryTime() <= current_time;
+  }
 
   bool GetSecondsSinceStarted(int64_t* seconds_since_started);
   bool GetSecondsSinceLastPlayed(int64_t* seconds_since_started);
@@ -89,6 +93,9 @@ class PolicyEngine {
     kLicenseStateExpired
   } LicenseState;
 
+  int64_t GetLicenseExpiryTime();
+  int64_t GetPlaybackExpiryTime();
+
   int64_t GetLicenseDurationRemaining(int64_t current_time);
   int64_t GetPlaybackDurationRemaining(int64_t current_time);
 
@@ -98,6 +105,10 @@ class PolicyEngine {
 
   void UpdateRenewalRequest(int64_t current_time);
 
+  // Notifies updates in expiry time and fire OnExpirationUpdate event if
+  // expiry time changes.
+  void NotifyExpirationUpdate();
+
   // These setters are for testing only. Takes ownership of the pointers.
   void set_clock(Clock* clock);
 
@@ -119,6 +130,7 @@ class PolicyEngine {
   int64_t license_start_time_;
   int64_t playback_start_time_;
   int64_t last_playback_time_;
+  int64_t last_expiry_time_;
 
   // This is used as a reference point for policy management. This value
   // represents an offset from license_start_time_. This is used to

libwvdrmengine/cdm/core/include/wv_cdm_event_listener.h

@@ -15,6 +15,8 @@ class WvCdmEventListener {
 
   virtual void OnSessionRenewalNeeded(const CdmSessionId& session_id) = 0;
   virtual void OnSessionExpiration(const CdmSessionId& session_id) = 0;
+  virtual void OnExpirationUpdate(const CdmSessionId& session_id,
+                                  int64_t new_expiry_time) = 0;
 
  private:
   CORE_DISALLOW_COPY_AND_ASSIGN(WvCdmEventListener);

libwvdrmengine/cdm/core/src/policy_engine.cpp

@@ -25,6 +25,7 @@ PolicyEngine::PolicyEngine(CdmSessionId session_id,
       license_start_time_(0),
       playback_start_time_(0),
       last_playback_time_(0),
+      last_expiry_time_(0),
       next_renewal_time_(0),
       policy_max_duration_seconds_(0),
       session_id_(session_id),
@@ -163,6 +164,7 @@ void PolicyEngine::UpdateLicense(
     license_state_ = kLicenseStatePending;
     can_decrypt_ = false;
   }
+  NotifyExpirationUpdate();
 }
 
 void PolicyEngine::BeginDecryption() {
@@ -177,6 +179,7 @@ void PolicyEngine::BeginDecryption() {
         if (policy_.renew_with_usage()) {
           license_state_ = kLicenseStateNeedRenewal;
         }
+        NotifyExpirationUpdate();
         break;
       case kLicenseStateInitial:
       case kLicenseStatePending:
@@ -243,6 +246,7 @@ void PolicyEngine::RestorePlaybackTimes(int64_t playback_start_time,
                                         int64_t last_playback_time) {
   playback_start_time_ = (playback_start_time > 0) ? playback_start_time : 0;
   last_playback_time_ = (last_playback_time > 0) ? last_playback_time : 0;
+  NotifyExpirationUpdate();
 }
 
 void PolicyEngine::UpdateRenewalRequest(int64_t current_time) {
@@ -253,39 +257,32 @@ void PolicyEngine::UpdateRenewalRequest(int64_t 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.
-bool PolicyEngine::IsLicenseDurationExpired(int64_t current_time) {
-  return policy_max_duration_seconds_ &&
-         license_start_time_ + policy_max_duration_seconds_ <= current_time;
+int64_t PolicyEngine::GetLicenseExpiryTime() {
+  return policy_max_duration_seconds_ > 0
+             ? license_start_time_ + policy_max_duration_seconds_
+             : LLONG_MAX;
+}
+
+int64_t PolicyEngine::GetPlaybackExpiryTime() {
+  return (playback_start_time_ > 0 && policy_.playback_duration_seconds() > 0)
+             ? (playback_start_time_ + policy_.playback_duration_seconds())
+             : LLONG_MAX;
 }
 
 int64_t PolicyEngine::GetLicenseDurationRemaining(int64_t current_time) {
-  if (0 == policy_max_duration_seconds_) return LLONG_MAX;
-
-  int64_t remaining_time =
-      policy_max_duration_seconds_ + license_start_time_ - current_time;
-
-  if (remaining_time < 0)
-    remaining_time = 0;
-  else if (remaining_time > policy_max_duration_seconds_)
-    remaining_time = policy_max_duration_seconds_;
-  return remaining_time;
-}
-
-bool PolicyEngine::IsPlaybackDurationExpired(int64_t current_time) {
-  return (policy_.playback_duration_seconds() > 0) && playback_start_time_ &&
-         playback_start_time_ + policy_.playback_duration_seconds() <=
-             current_time;
+  if (policy_max_duration_seconds_ == 0) return LLONG_MAX;
+  int64_t license_expiry_time = GetLicenseExpiryTime();
+  if (license_expiry_time < current_time) return 0;
+  return std::min(license_expiry_time - current_time,
+                  policy_max_duration_seconds_);
 }
 
 int64_t PolicyEngine::GetPlaybackDurationRemaining(int64_t current_time) {
-  if (0 == policy_.playback_duration_seconds()) return LLONG_MAX;
-  if (0 == playback_start_time_) return policy_.playback_duration_seconds();
-
-  int64_t remaining_time =
-      policy_.playback_duration_seconds() + playback_start_time_ - current_time;
-
-  if (remaining_time < 0) remaining_time = 0;
-  return remaining_time;
+  if (policy_.playback_duration_seconds() == 0) return LLONG_MAX;
+  int64_t playback_expiry_time = GetPlaybackExpiryTime();
+  if (playback_expiry_time < current_time) return 0;
+  return std::min(playback_expiry_time - current_time,
+                  policy_.playback_duration_seconds());
 }
 
 bool PolicyEngine::IsRenewalDelayExpired(int64_t current_time) {
@@ -306,6 +303,16 @@ bool PolicyEngine::IsRenewalRetryIntervalExpired(int64_t current_time) {
          next_renewal_time_ <= current_time;
 }
 
+void PolicyEngine::NotifyExpirationUpdate() {
+  int64_t expiry_time =
+      std::min(GetLicenseExpiryTime(), GetPlaybackExpiryTime());
+  if (expiry_time != last_expiry_time_) {
+    last_expiry_time_ = expiry_time;
+    if (event_listener_)
+      event_listener_->OnExpirationUpdate(session_id_, expiry_time);
+  }
+}
+
 void PolicyEngine::set_clock(Clock* clock) { clock_.reset(clock); }
 
 }  // wvcdm

libwvdrmengine/cdm/core/test/policy_engine_unittest.cpp

@@ -18,6 +18,7 @@
 
 namespace {
 const int64_t kDurationUnlimited = 0;
+const int64_t kNoExpiration = LLONG_MAX;
 const int64_t kLicenseStartTime = 1413517500;   // ~ 01/01/2013
 const int64_t kRentalDuration = 604800;         // 7 days
 const int64_t kPlaybackDuration = 172800;       // 48 hours
@@ -67,6 +68,8 @@ class MockCdmEventListener : public WvCdmEventListener {
  public:
   MOCK_METHOD1(OnSessionRenewalNeeded, void(const CdmSessionId& session_id));
   MOCK_METHOD1(OnSessionExpiration, void(const CdmSessionId& session_id));
+  MOCK_METHOD2(OnExpirationUpdate,
+               void(const CdmSessionId& session_id, int64_t new_expiry_time));
 };
 
 class PolicyEngineTest : public ::testing::Test {
@@ -74,9 +77,7 @@ class PolicyEngineTest : public ::testing::Test {
   virtual void SetUp() {
     policy_engine_.reset(
         new PolicyEngine(kSessionId, &mock_event_listener_, NULL));
-    // Inject testing clock.
-    mock_clock_ = new MockClock();
-    policy_engine_->set_clock(mock_clock_);
+    InjectMockClock();
 
     license_.set_license_start_time(kLicenseStartTime);
 
@@ -114,6 +115,11 @@ class PolicyEngineTest : public ::testing::Test {
                     license_duration);
   }
 
+  void InjectMockClock() {
+    mock_clock_ = new MockClock();
+    policy_engine_->set_clock(mock_clock_);
+  }
+
   StrictMock<MockCdmEventListener> mock_event_listener_;
   MockClock* mock_clock_;
   scoped_ptr<PolicyEngine> policy_engine_;
@@ -131,6 +137,9 @@ TEST_F(PolicyEngineTest, PlaybackSuccess) {
       .WillOnce(Return(kLicenseStartTime + 5))
       .WillOnce(Return(kLicenseStartTime + 10));
 
+  EXPECT_CALL(mock_event_listener_,
+              OnExpirationUpdate(_, kLicenseStartTime + kLowDuration));
+
   policy_engine_->SetLicense(license_);
 
   policy_engine_->OnTimerEvent();
@@ -170,8 +179,10 @@ TEST_F(PolicyEngineTest, PlaybackFails_RentalDurationExpired) {
       .WillOnce(Return(kLicenseStartTime + min_duration));
 
   InSequence s;
+  EXPECT_CALL(mock_event_listener_,
+              OnExpirationUpdate(_, kLicenseStartTime + kLowDuration));
   EXPECT_CALL(check_, Call(1));
-  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(kSessionId)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(kSessionId));
   EXPECT_CALL(check_, Call(2));
 
   policy_engine_->SetLicense(license_);
@@ -200,8 +211,12 @@ TEST_F(PolicyEngineTest, PlaybackFails_PlaybackDurationExpired) {
       .WillOnce(Return(playback_start_time + kPlaybackDuration + 2));
 
   InSequence s;
+  EXPECT_CALL(mock_event_listener_,
+              OnExpirationUpdate(_, kLicenseStartTime + kHighDuration));
+  EXPECT_CALL(mock_event_listener_,
+              OnExpirationUpdate(_, playback_start_time + kPlaybackDuration));
   EXPECT_CALL(check_, Call(1));
-  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_));
   EXPECT_CALL(check_, Call(2));
 
   policy_engine_->SetLicense(license_);
@@ -229,8 +244,10 @@ TEST_F(PolicyEngineTest, PlaybackFails_LicenseDurationExpired) {
       .WillOnce(Return(kLicenseStartTime + min_duration));
 
   InSequence s;
+  EXPECT_CALL(mock_event_listener_,
+              OnExpirationUpdate(_, kLicenseStartTime + kLowDuration));
   EXPECT_CALL(check_, Call(1));
-  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_));
   EXPECT_CALL(check_, Call(2));
 
   policy_engine_->SetLicense(license_);
@@ -258,8 +275,10 @@ TEST_F(PolicyEngineTest, PlaybackFails_ExpiryBeforeRenewalDelay) {
       .WillOnce(Return(kLicenseStartTime + min_duration));
 
   InSequence s;
+  EXPECT_CALL(mock_event_listener_,
+              OnExpirationUpdate(_, kLicenseStartTime + kLowDuration));
   EXPECT_CALL(check_, Call(1));
-  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_));
   EXPECT_CALL(check_, Call(2));
 
   policy_engine_->SetLicense(license_);
@@ -290,12 +309,14 @@ TEST_F(PolicyEngineTest, PlaybackOk_RentalDuration0) {
       .WillOnce(Return(kLicenseStartTime + kStreamingLicenseDuration));
 
   InSequence s;
+  EXPECT_CALL(mock_event_listener_,
+              OnExpirationUpdate(_, kLicenseStartTime + kLowDuration));
   EXPECT_CALL(check_, Call(1));
-  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_));
   EXPECT_CALL(check_, Call(2));
-  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_));
   EXPECT_CALL(check_, Call(3));
-  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_));
   EXPECT_CALL(check_, Call(4));
 
   policy_engine_->SetLicense(license_);
@@ -327,12 +348,14 @@ TEST_F(PolicyEngineTest, PlaybackOk_PlaybackDuration0) {
       .WillOnce(Return(kLicenseStartTime + kHighDuration + 2));
 
   InSequence s;
+  EXPECT_CALL(mock_event_listener_,
+              OnExpirationUpdate(_, kLicenseStartTime + kHighDuration));
   EXPECT_CALL(check_, Call(1));
-  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_));
   EXPECT_CALL(check_, Call(2));
-  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_));
   EXPECT_CALL(check_, Call(3));
-  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_));
   EXPECT_CALL(check_, Call(4));
 
   policy_engine_->SetLicense(license_);
@@ -362,8 +385,10 @@ TEST_F(PolicyEngineTest, PlaybackOk_LicenseDuration0) {
       .WillOnce(Return(kLicenseStartTime + min_duration));
 
   InSequence s;
+  EXPECT_CALL(mock_event_listener_,
+              OnExpirationUpdate(_, kLicenseStartTime + kLowDuration));
   EXPECT_CALL(check_, Call(1));
-  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_));
   EXPECT_CALL(check_, Call(2));
 
   policy_engine_->SetLicense(license_);
@@ -392,6 +417,8 @@ TEST_F(PolicyEngineTest, PlaybackOk_Durations0) {
       .WillOnce(Return(kLicenseStartTime + kHighDuration - 1))
       .WillOnce(Return(kLicenseStartTime + kHighDuration));
 
+  EXPECT_CALL(mock_event_listener_, OnExpirationUpdate(_, kNoExpiration));
+
   policy_engine_->SetLicense(license_);
 
   policy_engine_->BeginDecryption();
@@ -410,6 +437,9 @@ TEST_F(PolicyEngineTest, PlaybackOk_LicenseWithFutureStartTime) {
       .WillOnce(Return(kLicenseStartTime))
       .WillOnce(Return(kLicenseStartTime + 10));
 
+  EXPECT_CALL(mock_event_listener_,
+              OnExpirationUpdate(_, kLicenseStartTime + kLowDuration));
+
   policy_engine_->SetLicense(license_);
 
   policy_engine_->OnTimerEvent();
@@ -436,9 +466,11 @@ TEST_F(PolicyEngineTest, PlaybackFailed_CanRenewFalse) {
       .WillOnce(Return(kLicenseStartTime + kStreamingLicenseDuration + 10));
 
   InSequence s;
+  EXPECT_CALL(mock_event_listener_,
+              OnExpirationUpdate(_, kLicenseStartTime + kLowDuration));
   EXPECT_CALL(check_, Call(1));
   EXPECT_CALL(check_, Call(2));
-  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_));
   EXPECT_CALL(check_, Call(3));
 
   policy_engine_->SetLicense(license_);
@@ -457,6 +489,8 @@ TEST_F(PolicyEngineTest, PlaybackFailed_CanRenewFalse) {
 TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccess) {
   int64_t license_renewal_delay =
       GetLicenseRenewalDelay(kStreamingLicenseDuration);
+  int64_t new_license_start_time =
+      kLicenseStartTime + license_renewal_delay + 15;
 
   EXPECT_CALL(*mock_clock_, GetCurrentTime())
       .WillOnce(Return(kLicenseStartTime + 1))
@@ -468,9 +502,13 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccess) {
                        kLicenseRenewalRetryInterval + 10));
 
   InSequence s;
+  EXPECT_CALL(mock_event_listener_,
+              OnExpirationUpdate(_, kLicenseStartTime + kLowDuration));
   EXPECT_CALL(check_, Call(1));
-  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)).Times(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_);
@@ -485,8 +523,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccess) {
 
   EXPECT_TRUE(policy_engine_->CanDecrypt(kKeyId));
 
-  license_.set_license_start_time(kLicenseStartTime + license_renewal_delay +
-                                  15);
+  license_.set_license_start_time(new_license_start_time);
   LicenseIdentification* id = license_.mutable_id();
   id->set_version(2);
   policy_engine_->UpdateLicense(license_);
@@ -500,6 +537,8 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccess) {
 TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccess_WithFutureStartTime) {
   int64_t license_renewal_delay =
       GetLicenseRenewalDelay(kStreamingLicenseDuration);
+  int64_t new_license_start_time =
+      kLicenseStartTime + license_renewal_delay + 50;
 
   EXPECT_CALL(*mock_clock_, GetCurrentTime())
       .WillOnce(Return(kLicenseStartTime + 1))
@@ -511,9 +550,13 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccess_WithFutureStartTime) {
       .WillOnce(Return(kLicenseStartTime + license_renewal_delay + 60));
 
   InSequence s;
+  EXPECT_CALL(mock_event_listener_,
+              OnExpirationUpdate(_, kLicenseStartTime + kLowDuration));
   EXPECT_CALL(check_, Call(1));
-  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)).Times(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));
   EXPECT_CALL(check_, Call(4));
 
@@ -528,8 +571,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccess_WithFutureStartTime) {
   }
   EXPECT_TRUE(policy_engine_->CanDecrypt(kKeyId));
 
-  license_.set_license_start_time(kLicenseStartTime + license_renewal_delay +
-                                  50);
+  license_.set_license_start_time(new_license_start_time);
   LicenseIdentification* id = license_.mutable_id();
   id->set_version(2);
   policy_engine_->UpdateLicense(license_);
@@ -556,12 +598,14 @@ TEST_F(PolicyEngineTest, PlaybackFailed_RenewFailedVersionNotUpdated) {
       .WillOnce(Return(kLicenseStartTime + kStreamingLicenseDuration + 10));
 
   InSequence s;
+  EXPECT_CALL(mock_event_listener_,
+              OnExpirationUpdate(_, kLicenseStartTime + kLowDuration));
   EXPECT_CALL(check_, Call(1));
-  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_));
   EXPECT_CALL(check_, Call(2));
-  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_));
   EXPECT_CALL(check_, Call(3));
-  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_));
   EXPECT_CALL(check_, Call(4));
 
   policy_engine_->SetLicense(license_);
@@ -608,17 +652,19 @@ TEST_F(PolicyEngineTest, PlaybackFailed_RepeatedRenewFailures) {
       .WillOnce(Return(kLicenseStartTime + kStreamingLicenseDuration + 15));
 
   InSequence s;
+  EXPECT_CALL(mock_event_listener_,
+              OnExpirationUpdate(_, kLicenseStartTime + kLowDuration));
   EXPECT_CALL(check_, Call(1));
-  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_));
   EXPECT_CALL(check_, Call(2));
   EXPECT_CALL(check_, Call(3));
-  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_));
   EXPECT_CALL(check_, Call(4));
   EXPECT_CALL(check_, Call(5));
-  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_));
   EXPECT_CALL(check_, Call(6));
   EXPECT_CALL(check_, Call(7));
-  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_));
   EXPECT_CALL(check_, Call(8));
 
   policy_engine_->SetLicense(license_);
@@ -636,6 +682,10 @@ TEST_F(PolicyEngineTest, PlaybackFailed_RepeatedRenewFailures) {
 TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccessAfterExpiry) {
   int64_t license_renewal_delay =
       GetLicenseRenewalDelay(kStreamingLicenseDuration);
+  int64_t new_license_start_time =
+      kLicenseStartTime + kStreamingLicenseDuration + 20;
+  int64_t new_playback_duration = kPlaybackDuration + 100;
+  int64_t new_license_duration = kStreamingLicenseDuration + 100;
 
   EXPECT_CALL(*mock_clock_, GetCurrentTime())
       .WillOnce(Return(kLicenseStartTime + 1))
@@ -652,18 +702,23 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccessAfterExpiry) {
       .WillOnce(Return(kLicenseStartTime + kStreamingLicenseDuration + 40));
 
   InSequence s;
+  EXPECT_CALL(mock_event_listener_,
+              OnExpirationUpdate(_, kLicenseStartTime + kLowDuration));
   EXPECT_CALL(check_, Call(1));
-  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_));
   EXPECT_CALL(check_, Call(2));
   EXPECT_CALL(check_, Call(3));
-  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_));
   EXPECT_CALL(check_, Call(4));
   EXPECT_CALL(check_, Call(5));
-  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_));
   EXPECT_CALL(check_, Call(6));
   EXPECT_CALL(check_, Call(7));
-  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_));
   EXPECT_CALL(check_, Call(8));
+  EXPECT_CALL(
+      mock_event_listener_,
+      OnExpirationUpdate(_, new_license_start_time + new_license_duration));
   EXPECT_CALL(check_, Call(9));
 
   policy_engine_->SetLicense(license_);
@@ -677,14 +732,13 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccessAfterExpiry) {
   }
   EXPECT_FALSE(policy_engine_->CanDecrypt(kKeyId));
 
-  license_.set_license_start_time(kLicenseStartTime +
-                                  kStreamingLicenseDuration + 20);
+  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 = license_.mutable_policy();
-  policy->set_playback_duration_seconds(kPlaybackDuration + 100);
-  policy->set_license_duration_seconds(kStreamingLicenseDuration + 100);
+  policy->set_playback_duration_seconds(new_playback_duration);
+  policy->set_license_duration_seconds(new_license_duration);
 
   policy_engine_->UpdateLicense(license_);
 
@@ -697,6 +751,8 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccessAfterExpiry) {
 TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccessAfterFailures) {
   int64_t license_renewal_delay =
       GetLicenseRenewalDelay(kStreamingLicenseDuration);
+  int64_t new_license_start_time =
+      kLicenseStartTime + license_renewal_delay + 55;
 
   EXPECT_CALL(*mock_clock_, GetCurrentTime())
       .WillOnce(Return(kLicenseStartTime + 1))
@@ -711,13 +767,17 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccessAfterFailures) {
       .WillOnce(Return(kLicenseStartTime + license_renewal_delay + 200));
 
   InSequence s;
+  EXPECT_CALL(mock_event_listener_,
+              OnExpirationUpdate(_, kLicenseStartTime + kLowDuration));
   EXPECT_CALL(check_, Call(1));
-  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_));
   EXPECT_CALL(check_, Call(2));
   EXPECT_CALL(check_, Call(3));
-  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)).Times(1);
+  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_));
   EXPECT_CALL(check_, Call(4));
   EXPECT_CALL(check_, Call(5));
+  EXPECT_CALL(mock_event_listener_,
+              OnExpirationUpdate(_, new_license_start_time + kLowDuration));
   EXPECT_CALL(check_, Call(6));
   EXPECT_CALL(check_, Call(7));
 
@@ -731,8 +791,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccessAfterFailures) {
     check_.Call(i);
   }
 
-  license_.set_license_start_time(kLicenseStartTime + license_renewal_delay +
-                                  55);
+  license_.set_license_start_time(new_license_start_time);
   LicenseIdentification* id = license_.mutable_id();
   id->set_version(2);
   policy_engine_->UpdateLicense(license_);
@@ -745,6 +804,8 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewSuccessAfterFailures) {
 }
 
 TEST_F(PolicyEngineTest, PlaybackOk_RenewedWithUsage) {
+  int64_t new_license_start_time = kLicenseStartTime + 30;
+
   License_Policy* policy = license_.mutable_policy();
   policy->set_renew_with_usage(true);
 
@@ -757,9 +818,13 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewedWithUsage) {
       .WillOnce(Return(kLicenseStartTime + 50));
 
   InSequence s;
+  EXPECT_CALL(mock_event_listener_,
+              OnExpirationUpdate(_, kLicenseStartTime + kLowDuration));
   EXPECT_CALL(check_, Call(1));
-  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)).Times(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_);
@@ -773,7 +838,7 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewedWithUsage) {
   policy_engine_->OnTimerEvent();
   check_.Call(2);
 
-  license_.set_license_start_time(kLicenseStartTime + 30);
+  license_.set_license_start_time(new_license_start_time);
   policy->set_renew_with_usage(false);
   LicenseIdentification* id = license_.mutable_id();
   id->set_version(2);
@@ -785,7 +850,16 @@ TEST_F(PolicyEngineTest, PlaybackOk_RenewedWithUsage) {
   EXPECT_TRUE(policy_engine_->CanDecrypt(kKeyId));
 }
 
-TEST_F(PolicyEngineTest, QuerySuccess_LicenseNotReceived) {
+class PolicyEngineQueryTest : public PolicyEngineTest {
+ protected:
+  virtual void SetUp() {
+    PolicyEngineTest::SetUp();
+    policy_engine_.reset(new PolicyEngine(kSessionId, NULL, NULL));
+    InjectMockClock();
+  }
+};
+
+TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseNotReceived) {
   EXPECT_CALL(*mock_clock_, GetCurrentTime())
       .WillOnce(Return(kLicenseStartTime));
 
@@ -794,7 +868,7 @@ TEST_F(PolicyEngineTest, QuerySuccess_LicenseNotReceived) {
   EXPECT_EQ(0u, query_info.size());
 }
 
-TEST_F(PolicyEngineTest, QuerySuccess_LicenseStartTimeNotSet) {
+TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseStartTimeNotSet) {
   license_.clear_license_start_time();
 
   EXPECT_CALL(*mock_clock_, GetCurrentTime())
@@ -807,7 +881,7 @@ TEST_F(PolicyEngineTest, QuerySuccess_LicenseStartTimeNotSet) {
   EXPECT_EQ(0u, query_info.size());
 }
 
-TEST_F(PolicyEngineTest, QuerySuccess) {
+TEST_F(PolicyEngineQueryTest, QuerySuccess) {
   EXPECT_CALL(*mock_clock_, GetCurrentTime())
       .WillOnce(Return(kLicenseStartTime + 1))
       .WillOnce(Return(kLicenseStartTime + 100));
@@ -833,7 +907,7 @@ TEST_F(PolicyEngineTest, QuerySuccess) {
   EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
 }
 
-TEST_F(PolicyEngineTest, QuerySuccess_PlaybackNotBegun) {
+TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackNotBegun) {
   EXPECT_CALL(*mock_clock_, GetCurrentTime())
       .WillOnce(Return(kLicenseStartTime + 1))
       .WillOnce(Return(kLicenseStartTime + 100))
@@ -876,7 +950,7 @@ TEST_F(PolicyEngineTest, QuerySuccess_PlaybackNotBegun) {
   EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
 }
 
-TEST_F(PolicyEngineTest, QuerySuccess_PlaybackBegun) {
+TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackBegun) {
   EXPECT_CALL(*mock_clock_, GetCurrentTime())
       .WillOnce(Return(kLicenseStartTime + 1))
       .WillOnce(Return(kLicenseStartTime + 50))
@@ -926,7 +1000,7 @@ TEST_F(PolicyEngineTest, QuerySuccess_PlaybackBegun) {
   EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
 }
 
-TEST_F(PolicyEngineTest, QuerySuccess_Offline) {
+TEST_F(PolicyEngineQueryTest, QuerySuccess_Offline) {
   LicenseIdentification* id = license_.mutable_id();
   id->set_type(OFFLINE);
 
@@ -969,7 +1043,7 @@ TEST_F(PolicyEngineTest, QuerySuccess_Offline) {
   EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
 }
 
-TEST_F(PolicyEngineTest, QuerySuccess_InitialRentalDurationExpired) {
+TEST_F(PolicyEngineQueryTest, QuerySuccess_InitialRentalDurationExpired) {
   License_Policy* policy = license_.mutable_policy();
   policy->set_rental_duration_seconds(kLowDuration);
   policy->set_license_duration_seconds(kHighDuration);
@@ -1001,7 +1075,7 @@ TEST_F(PolicyEngineTest, QuerySuccess_InitialRentalDurationExpired) {
   EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
 }
 
-TEST_F(PolicyEngineTest, QuerySuccess_InitialLicenseDurationExpired) {
+TEST_F(PolicyEngineQueryTest, QuerySuccess_InitialLicenseDurationExpired) {
   EXPECT_CALL(*mock_clock_, GetCurrentTime())
       .WillOnce(Return(kLicenseStartTime + kStreamingLicenseDuration + 1))
       .WillOnce(Return(kLicenseStartTime + kStreamingLicenseDuration + 5));
@@ -1029,7 +1103,7 @@ TEST_F(PolicyEngineTest, QuerySuccess_InitialLicenseDurationExpired) {
   EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
 }
 
-TEST_F(PolicyEngineTest, QuerySuccess_CanPlayFalse) {
+TEST_F(PolicyEngineQueryTest, QuerySuccess_CanPlayFalse) {
   LicenseIdentification* id = license_.mutable_id();
   id->set_type(OFFLINE);
 
@@ -1072,7 +1146,7 @@ TEST_F(PolicyEngineTest, QuerySuccess_CanPlayFalse) {
   EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
 }
 
-TEST_F(PolicyEngineTest, QuerySuccess_RentalDurationExpired) {
+TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalDurationExpired) {
   License_Policy* policy = license_.mutable_policy();
   policy->set_rental_duration_seconds(kLowDuration);
   policy->set_license_duration_seconds(kHighDuration);
@@ -1086,11 +1160,6 @@ TEST_F(PolicyEngineTest, QuerySuccess_RentalDurationExpired) {
       .WillOnce(Return(kLicenseStartTime + min_duration))
       .WillOnce(Return(kLicenseStartTime + min_duration + 5));
 
-  InSequence s;
-  EXPECT_CALL(check_, Call(1));
-  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_)).Times(1);
-  EXPECT_CALL(check_, Call(2));
-
   policy_engine_->SetLicense(license_);
 
   policy_engine_->BeginDecryption();
@@ -1098,7 +1167,6 @@ TEST_F(PolicyEngineTest, QuerySuccess_RentalDurationExpired) {
 
   for (int i = 1; i <= 2; ++i) {
     policy_engine_->OnTimerEvent();
-    check_.Call(i);
   }
 
   EXPECT_FALSE(policy_engine_->CanDecrypt(kKeyId));
@@ -1122,7 +1190,7 @@ TEST_F(PolicyEngineTest, QuerySuccess_RentalDurationExpired) {
   EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
 }
 
-TEST_F(PolicyEngineTest, QuerySuccess_PlaybackDurationExpired) {
+TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDurationExpired) {
   License_Policy* policy = license_.mutable_policy();
   policy->set_playback_duration_seconds(kLowDuration);
   policy->set_license_duration_seconds(kHighDuration);
@@ -1137,11 +1205,6 @@ TEST_F(PolicyEngineTest, QuerySuccess_PlaybackDurationExpired) {
       .WillOnce(Return(playback_start_time + 2 + min_duration))
       .WillOnce(Return(playback_start_time + 5 + min_duration));
 
-  InSequence s;
-  EXPECT_CALL(check_, Call(1));
-  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_)).Times(1);
-  EXPECT_CALL(check_, Call(2));
-
   policy_engine_->SetLicense(license_);
 
   policy_engine_->BeginDecryption();
@@ -1149,7 +1212,6 @@ TEST_F(PolicyEngineTest, QuerySuccess_PlaybackDurationExpired) {
 
   for (int i = 1; i <= 2; ++i) {
     policy_engine_->OnTimerEvent();
-    check_.Call(i);
   }
 
   EXPECT_FALSE(policy_engine_->CanDecrypt(kKeyId));
@@ -1173,7 +1235,7 @@ TEST_F(PolicyEngineTest, QuerySuccess_PlaybackDurationExpired) {
   EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
 }
 
-TEST_F(PolicyEngineTest, QuerySuccess_LicenseDurationExpired) {
+TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseDurationExpired) {
   License_Policy* policy = license_.mutable_policy();
   policy->set_can_renew(false);
   int64_t min_duration = GetMinOfRentalPlaybackLicenseDurations();
@@ -1185,11 +1247,6 @@ TEST_F(PolicyEngineTest, QuerySuccess_LicenseDurationExpired) {
       .WillOnce(Return(kLicenseStartTime + min_duration))
       .WillOnce(Return(kLicenseStartTime + min_duration + 5));
 
-  InSequence s;
-  EXPECT_CALL(check_, Call(1));
-  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_)).Times(1);
-  EXPECT_CALL(check_, Call(2));
-
   policy_engine_->SetLicense(license_);
 
   policy_engine_->BeginDecryption();
@@ -1197,7 +1254,6 @@ TEST_F(PolicyEngineTest, QuerySuccess_LicenseDurationExpired) {
 
   for (int i = 1; i <= 2; ++i) {
     policy_engine_->OnTimerEvent();
-    check_.Call(i);
   }
 
   EXPECT_FALSE(policy_engine_->CanDecrypt(kKeyId));
@@ -1221,7 +1277,7 @@ TEST_F(PolicyEngineTest, QuerySuccess_LicenseDurationExpired) {
   EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
 }
 
-TEST_F(PolicyEngineTest, QuerySuccess_RentalDuration0) {
+TEST_F(PolicyEngineQueryTest, QuerySuccess_RentalDuration0) {
   License_Policy* policy = license_.mutable_policy();
   policy->set_rental_duration_seconds(kDurationUnlimited);
   int64_t license_renewal_delay =
@@ -1236,15 +1292,6 @@ TEST_F(PolicyEngineTest, QuerySuccess_RentalDuration0) {
       .WillOnce(Return(kLicenseStartTime + kStreamingLicenseDuration))
       .WillOnce(Return(kLicenseStartTime + kStreamingLicenseDuration + 5));
 
-  InSequence s;
-  EXPECT_CALL(check_, Call(1));
-  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)).Times(1);
-  EXPECT_CALL(check_, Call(2));
-  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)).Times(1);
-  EXPECT_CALL(check_, Call(3));
-  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_)).Times(1);
-  EXPECT_CALL(check_, Call(4));
-
   policy_engine_->SetLicense(license_);
 
   policy_engine_->BeginDecryption();
@@ -1252,7 +1299,6 @@ TEST_F(PolicyEngineTest, QuerySuccess_RentalDuration0) {
 
   for (int i = 1; i <= 4; ++i) {
     policy_engine_->OnTimerEvent();
-    check_.Call(i);
   }
 
   EXPECT_FALSE(policy_engine_->CanDecrypt(kKeyId));
@@ -1276,7 +1322,7 @@ TEST_F(PolicyEngineTest, QuerySuccess_RentalDuration0) {
   EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
 }
 
-TEST_F(PolicyEngineTest, QuerySuccess_PlaybackDuration0) {
+TEST_F(PolicyEngineQueryTest, QuerySuccess_PlaybackDuration0) {
   License_Policy* policy = license_.mutable_policy();
   policy->set_playback_duration_seconds(kDurationUnlimited);
   policy->set_license_duration_seconds(kHighDuration);
@@ -1293,15 +1339,6 @@ TEST_F(PolicyEngineTest, QuerySuccess_PlaybackDuration0) {
       .WillOnce(Return(kLicenseStartTime + kHighDuration + 2))
       .WillOnce(Return(kLicenseStartTime + kHighDuration + 5));
 
-  InSequence s;
-  EXPECT_CALL(check_, Call(1));
-  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)).Times(1);
-  EXPECT_CALL(check_, Call(2));
-  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)).Times(1);
-  EXPECT_CALL(check_, Call(3));
-  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_)).Times(1);
-  EXPECT_CALL(check_, Call(4));
-
   policy_engine_->SetLicense(license_);
 
   policy_engine_->BeginDecryption();
@@ -1309,7 +1346,6 @@ TEST_F(PolicyEngineTest, QuerySuccess_PlaybackDuration0) {
 
   for (int i = 1; i <= 2; ++i) {
     policy_engine_->OnTimerEvent();
-    check_.Call(i);
   }
 
   CdmQueryMap query_info;
@@ -1332,7 +1368,6 @@ TEST_F(PolicyEngineTest, QuerySuccess_PlaybackDuration0) {
 
   for (int i = 3; i <= 4; ++i) {
     policy_engine_->OnTimerEvent();
-    check_.Call(i);
   }
 
   EXPECT_FALSE(policy_engine_->CanDecrypt(kKeyId));
@@ -1354,7 +1389,7 @@ TEST_F(PolicyEngineTest, QuerySuccess_PlaybackDuration0) {
   EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
 }
 
-TEST_F(PolicyEngineTest, QuerySuccess_LicenseDuration0) {
+TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseDuration0) {
   License_Policy* policy = license_.mutable_policy();
   policy->set_license_duration_seconds(kDurationUnlimited);
   policy->set_rental_duration_seconds(kStreamingLicenseDuration);
@@ -1368,11 +1403,6 @@ TEST_F(PolicyEngineTest, QuerySuccess_LicenseDuration0) {
       .WillOnce(Return(kLicenseStartTime + min_duration))
       .WillOnce(Return(kLicenseStartTime + min_duration + 5));
 
-  InSequence s;
-  EXPECT_CALL(check_, Call(1));
-  EXPECT_CALL(mock_event_listener_, OnSessionExpiration(_)).Times(1);
-  EXPECT_CALL(check_, Call(2));
-
   policy_engine_->SetLicense(license_);
 
   policy_engine_->BeginDecryption();
@@ -1380,7 +1410,6 @@ TEST_F(PolicyEngineTest, QuerySuccess_LicenseDuration0) {
 
   for (int i = 1; i <= 2; ++i) {
     policy_engine_->OnTimerEvent();
-    check_.Call(i);
   }
 
   EXPECT_FALSE(policy_engine_->CanDecrypt(kKeyId));
@@ -1404,7 +1433,7 @@ TEST_F(PolicyEngineTest, QuerySuccess_LicenseDuration0) {
   EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
 }
 
-TEST_F(PolicyEngineTest, QuerySuccess_Durations0) {
+TEST_F(PolicyEngineQueryTest, QuerySuccess_Durations0) {
   License_Policy* policy = license_.mutable_policy();
   policy->set_rental_duration_seconds(kDurationUnlimited);
   policy->set_playback_duration_seconds(kDurationUnlimited);
@@ -1447,7 +1476,7 @@ TEST_F(PolicyEngineTest, QuerySuccess_Durations0) {
   EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
 }
 
-TEST_F(PolicyEngineTest, QuerySuccess_LicenseWithFutureStartTime) {
+TEST_F(PolicyEngineQueryTest, QuerySuccess_LicenseWithFutureStartTime) {
   EXPECT_CALL(*mock_clock_, GetCurrentTime())
       .WillOnce(Return(kLicenseStartTime - 100))
       .WillOnce(Return(kLicenseStartTime - 50))
@@ -1502,7 +1531,7 @@ TEST_F(PolicyEngineTest, QuerySuccess_LicenseWithFutureStartTime) {
   EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
 }
 
-TEST_F(PolicyEngineTest, QuerySuccess_Renew) {
+TEST_F(PolicyEngineQueryTest, QuerySuccess_Renew) {
   int64_t license_renewal_delay =
       GetLicenseRenewalDelay(kStreamingLicenseDuration);
 
@@ -1517,12 +1546,6 @@ TEST_F(PolicyEngineTest, QuerySuccess_Renew) {
       .WillOnce(Return(kLicenseStartTime + license_renewal_delay +
                        kLicenseRenewalRetryInterval + 15));
 
-  InSequence s;
-  EXPECT_CALL(check_, Call(1));
-  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)).Times(1);
-  EXPECT_CALL(check_, Call(2));
-  EXPECT_CALL(check_, Call(3));
-
   policy_engine_->SetLicense(license_);
 
   policy_engine_->BeginDecryption();
@@ -1530,7 +1553,6 @@ TEST_F(PolicyEngineTest, QuerySuccess_Renew) {
 
   for (int i = 1; i <= 2; ++i) {
     policy_engine_->OnTimerEvent();
-    check_.Call(i);
   }
 
   EXPECT_TRUE(policy_engine_->CanDecrypt(kKeyId));
@@ -1542,7 +1564,6 @@ TEST_F(PolicyEngineTest, QuerySuccess_Renew) {
   policy_engine_->UpdateLicense(license_);
 
   policy_engine_->OnTimerEvent();
-  check_.Call(3);
   EXPECT_TRUE(policy_engine_->CanDecrypt(kKeyId));
 
   CdmQueryMap query_info;
@@ -1567,7 +1588,7 @@ TEST_F(PolicyEngineTest, QuerySuccess_Renew) {
   EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
 }
 
-TEST_F(PolicyEngineTest, QuerySuccess_RenewWithFutureStartTime) {
+TEST_F(PolicyEngineQueryTest, QuerySuccess_RenewWithFutureStartTime) {
   int64_t license_renewal_delay =
       GetLicenseRenewalDelay(kStreamingLicenseDuration);
 
@@ -1586,13 +1607,6 @@ TEST_F(PolicyEngineTest, QuerySuccess_RenewWithFutureStartTime) {
       .WillOnce(Return(kLicenseStartTime + license_renewal_delay +
                        kLicenseRenewalRetryInterval + 40));
 
-  InSequence s;
-  EXPECT_CALL(check_, Call(1));
-  EXPECT_CALL(mock_event_listener_, OnSessionRenewalNeeded(_)).Times(1);
-  EXPECT_CALL(check_, Call(2));
-  EXPECT_CALL(check_, Call(3));
-  EXPECT_CALL(check_, Call(4));
-
   policy_engine_->SetLicense(license_);
 
   policy_engine_->BeginDecryption();
@@ -1600,7 +1614,6 @@ TEST_F(PolicyEngineTest, QuerySuccess_RenewWithFutureStartTime) {
 
   for (int i = 1; i <= 2; ++i) {
     policy_engine_->OnTimerEvent();
-    check_.Call(i);
   }
 
   EXPECT_TRUE(policy_engine_->CanDecrypt(kKeyId));
@@ -1612,7 +1625,6 @@ TEST_F(PolicyEngineTest, QuerySuccess_RenewWithFutureStartTime) {
   policy_engine_->UpdateLicense(license_);
 
   policy_engine_->OnTimerEvent();
-  check_.Call(3);
   EXPECT_FALSE(policy_engine_->CanDecrypt(kKeyId));
 
   CdmQueryMap query_info;
@@ -1636,7 +1648,6 @@ TEST_F(PolicyEngineTest, QuerySuccess_RenewWithFutureStartTime) {
   EXPECT_EQ(kRenewalServerUrl, query_info[QUERY_KEY_RENEWAL_SERVER_URL]);
 
   policy_engine_->OnTimerEvent();
-  check_.Call(4);
   EXPECT_TRUE(policy_engine_->CanDecrypt(kKeyId));
 
   EXPECT_EQ(NO_ERROR, policy_engine_->Query(&query_info));

libwvdrmengine/cdm/test/cdm_extended_duration_test.cpp

@@ -21,7 +21,6 @@
 #include "test_base.h"
 #include "url_request.h"
 #include "wv_cdm_constants.h"
-#include "wv_cdm_event_listener.h"
 #include "wv_content_decryption_module.h"
 
 namespace {

libwvdrmengine/cdm/test/request_license_test.cpp

@@ -444,6 +444,8 @@ class TestWvCdmEventListener : public WvCdmEventListener {
 
   MOCK_METHOD1(OnSessionRenewalNeeded, void(const CdmSessionId& session_id));
   MOCK_METHOD1(OnSessionExpiration, void(const CdmSessionId& session_id));
+  MOCK_METHOD2(OnExpirationUpdate,
+               void(const CdmSessionId& session_id, int64_t new_expiry_time));
 };
 
 class WvCdmRequestLicenseTest : public WvCdmTestBase {
@@ -1157,6 +1159,7 @@ TEST_F(WvCdmRequestLicenseTest, ExpiryOnReleaseOfflineKeyTest) {
   ::testing::StrictMock<TestWvCdmEventListener> listener;
   decryptor_.OpenSession(g_key_system, NULL, &listener, &session_id_);
   CdmSessionId restore_session_id = session_id_;
+  EXPECT_CALL(listener, OnExpirationUpdate(restore_session_id, ::testing::_));
   EXPECT_EQ(wvcdm::KEY_ADDED,
             decryptor_.RestoreKey(restore_session_id, key_set_id));
 
@@ -1165,7 +1168,7 @@ TEST_F(WvCdmRequestLicenseTest, ExpiryOnReleaseOfflineKeyTest) {
   // Maybe called since VerifyKeyRequestResponse could take some time.
   EXPECT_CALL(listener, OnSessionRenewalNeeded(restore_session_id))
       .Times(::testing::AtLeast(0));
-  EXPECT_CALL(listener, OnSessionExpiration(restore_session_id)).Times(1);
+  EXPECT_CALL(listener, OnSessionExpiration(restore_session_id));
   GenerateKeyRelease(key_set_id);
   key_set_id_ = key_set_id;
   VerifyKeyRequestResponse(g_license_server, client_auth, false);

libwvdrmengine/mediadrm/include/WVDrmPlugin.h

@@ -143,6 +143,9 @@ class WVDrmPlugin : public android::DrmPlugin,
 
   virtual void OnSessionExpiration(const CdmSessionId& cdmSessionId);
 
+  virtual void OnExpirationUpdate(const CdmSessionId& cdmSessionId,
+                                  int64_t new_expiry_time);
+
  private:
   DISALLOW_EVIL_CONSTRUCTORS(WVDrmPlugin);
 

libwvdrmengine/mediadrm/src/WVDrmPlugin.cpp

@@ -954,6 +954,12 @@ void WVDrmPlugin::OnSessionExpiration(const CdmSessionId& cdmSessionId) {
   sendEvent(kDrmPluginEventKeyExpired, 0, &sessionId, NULL);
 }
 
+void WVDrmPlugin::OnExpirationUpdate(const CdmSessionId& cdmSessionId,
+                                     int64_t new_expiry_time) {
+  // TODO(kqyang): Glue with DrmPlugin API when it is ready. Note that
+  // new_expiry_time is in seconds while Android API is in milliseconds.
+}
+
 status_t WVDrmPlugin::mapAndNotifyOfCdmResponseType(
     const Vector<uint8_t>& sessionId,
     CdmResponseType res) {