Source release v3.2.0

core/include/policy_engine.h

@@ -13,7 +13,7 @@
 
 namespace wvcdm {
 
-using video_widevine_server::sdk::LicenseIdentification;
+using video_widevine::LicenseIdentification;
 
 class Clock;
 class CryptoSession;
@@ -32,7 +32,7 @@ class PolicyEngine {
   // UpdateLicense/OnTimerEvent/BeginDecryption and may be out of sync
   // depending on the amount of time elapsed. The current decryption
   // status is not calculated to avoid overhead in the decryption path.
-  virtual bool CanDecrypt(const KeyId& key_id);
+  virtual bool CanDecryptContent(const KeyId& key_id);
 
   // OnTimerEvent is called when a timer fires. It notifies the Policy Engine
   // that the timer has fired and dispatches the relevant events through
@@ -43,12 +43,12 @@ class PolicyEngine {
   // an exact copy of the policy information stored in the license.
   // The license state transitions to kLicenseStateCanPlay if the license
   // permits playback.
-  virtual void SetLicense(const video_widevine_server::sdk::License& license);
+  virtual void SetLicense(const video_widevine::License& license);
 
   // SetLicenseForRelease is used when releasing a license. The keys in this
   // license will be ignored, and any old keys will be expired.
   virtual void SetLicenseForRelease(
-      const video_widevine_server::sdk::License& license);
+      const video_widevine::License& license);
 
   // Call this on first decrypt to set the start of playback.
   virtual void BeginDecryption(void);
@@ -60,7 +60,7 @@ class PolicyEngine {
   // updated license_start_time from the server. The license will transition to
   // kLicenseStateCanPlay if the license permits playback.
   virtual void UpdateLicense(
-      const video_widevine_server::sdk::License& license);
+      const video_widevine::License& license);
 
   // Used for notifying the Policy Engine of resolution changes
   virtual void NotifyResolution(uint32_t width, uint32_t height);
@@ -80,13 +80,21 @@ class PolicyEngine {
   // for offline save and restore
   int64_t GetPlaybackStartTime() { return playback_start_time_; }
   int64_t GetLastPlaybackTime() { return last_playback_time_; }
+  int64_t GetGracePeriodEndTime() { return grace_period_end_time_; }
   void RestorePlaybackTimes(int64_t playback_start_time,
-                            int64_t last_playback_time);
+                            int64_t last_playback_time,
+                            int64_t grace_period_end_time);
 
   bool IsLicenseForFuture() { return license_state_ == kLicenseStatePending; }
-  bool IsPlaybackStarted() { return playback_start_time_ > 0; }
+  bool HasPlaybackStarted(int64_t current_time) {
+    if (playback_start_time_ == 0)
+      return false;
 
-  bool IsLicenseOrPlaybackDurationExpired(int64_t current_time);
+    const int64_t playback_time = current_time - playback_start_time_;
+    return playback_time >= policy_.play_start_grace_period_seconds();
+  }
+
+  bool HasLicenseOrPlaybackDurationExpired(int64_t current_time);
   int64_t GetLicenseOrPlaybackDurationRemaining();
 
   bool CanRenew() { return policy_.can_renew(); }
@@ -111,15 +119,22 @@ 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 current_time, bool is_load);
 
-  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);
-  bool IsRenewalRecoveryDurationExpired(int64_t current_time);
-  bool IsRenewalRetryIntervalExpired(int64_t current_time);
+  bool HasRenewalDelayExpired(int64_t current_time);
+  bool HasRenewalRecoveryDurationExpired(int64_t current_time);
+  bool HasRenewalRetryIntervalExpired(int64_t current_time);
 
   void UpdateRenewalRequest(int64_t current_time);
 
@@ -129,7 +144,7 @@ class PolicyEngine {
 
   // Notifies updates in expiry time and fire OnExpirationUpdate event if
   // expiry time changes.
-  void NotifyExpirationUpdate();
+  void NotifyExpirationUpdate(int64_t current_time);
 
   // set_clock() is for testing only. It alters ownership of the
   // passed-in pointer.
@@ -139,12 +154,12 @@ class PolicyEngine {
 
   // This is the current policy information for this license. This gets updated
   // as license renewals occur.
-  video_widevine_server::sdk::License::Policy policy_;
+  video_widevine::License::Policy policy_;
 
   // This is the license id field from server response. This data gets passed
   // back to the server in each renewal request. When we get a renewal response
   // from the license server we will get an updated id field.
-  video_widevine_server::sdk::LicenseIdentification license_id_;
+  video_widevine::LicenseIdentification license_id_;
 
   // The server returns the license start time in the license/license renewal
   // response based off the request time sent by the client in the
@@ -153,13 +168,14 @@ class PolicyEngine {
   int64_t playback_start_time_;
   int64_t last_playback_time_;
   int64_t last_expiry_time_;
+  int64_t grace_period_end_time_;
   bool last_expiry_time_set_;
+  bool was_expired_on_load_;
 
   // This is used as a reference point for policy management. This value
   // 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_;