Source release 16.2.0

core/include/policy_engine.h

@@ -9,6 +9,7 @@
 #include <memory>
 #include <string>
 
+#include "clock.h"
 #include "disallow_copy_and_assign.h"
 #include "license_key_status.h"
 #include "license_protocol.pb.h"
@@ -21,6 +22,7 @@ using video_widevine::WidevinePsshData_EntitledKey;
 
 class Clock;
 class CryptoSession;
+class PolicyTimers;
 class WvCdmEventListener;
 
 // This acts as an oracle that basically says "Yes(true) you may still decrypt
@@ -56,7 +58,8 @@ 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::License& license);
+  virtual void SetLicense(const video_widevine::License& license,
+                          bool supports_core_messages);
 
   // Used to update the currently loaded entitled content keys.
   virtual void SetEntitledLicenseKeys(
@@ -64,10 +67,12 @@ class PolicyEngine {
 
   // 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::License& license);
+  virtual void SetLicenseForRelease(const video_widevine::License& license,
+                                    bool supports_core_messages);
 
   // Call this on first decrypt to set the start of playback.
   virtual bool BeginDecryption(void);
+  // Call this periodically to update the most recent playback time.
   virtual void DecryptionEvent(void);
 
   // UpdateLicense is used in handling a license response for a renewal request.
@@ -92,26 +97,20 @@ class PolicyEngine {
   bool GetSecondsSinceStarted(int64_t* seconds_since_started);
   bool GetSecondsSinceLastPlayed(int64_t* seconds_since_started);
 
-  // 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_; }
+  // For offline save and restore
+  int64_t GetPlaybackStartTime();
+  int64_t GetLastPlaybackTime();
+  int64_t GetGracePeriodEndTime();
   void RestorePlaybackTimes(int64_t playback_start_time,
                             int64_t last_playback_time,
                             int64_t grace_period_end_time);
 
   bool IsLicenseForFuture() { return license_state_ == kLicenseStatePending; }
-  bool HasPlaybackStarted(int64_t current_time) {
-    if (playback_start_time_ == 0) return false;
 
-    const int64_t playback_time = current_time - playback_start_time_;
-    return playback_time >= policy_.play_start_grace_period_seconds();
-  }
+  bool HasLicenseOrRentalOrPlaybackDurationExpired(int64_t current_time);
+  int64_t GetLicenseOrRentalOrPlaybackDurationRemaining();
 
-  bool HasLicenseOrPlaybackDurationExpired(int64_t current_time);
-  int64_t GetLicenseOrPlaybackDurationRemaining();
-
-  bool CanRenew() { return policy_.can_renew(); }
+  bool CanRenew() const;
 
   bool IsSufficientOutputProtection(const KeyId& key_id) {
     return license_keys_->MeetsConstraints(key_id);
@@ -135,26 +134,6 @@ class PolicyEngine {
     kLicenseStateExpired
   } LicenseState;
 
-  // 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 ignore_soft_enforce_playback_duration);
-
-  int64_t GetLicenseOrRentalDurationRemaining(int64_t current_time);
-  int64_t GetPlaybackDurationRemaining(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);
-
   // Notifies updates in keys information and fire OnKeysChange event if
   // key changes.
   void NotifyKeysChange(CdmKeyStatus new_status);
@@ -163,7 +142,8 @@ class PolicyEngine {
   // expiry time changes.
   void NotifyExpirationUpdate(int64_t current_time);
 
-  // Guard against clock rollbacks
+  void UpdateRenewalRequest(int64_t current_time);
+
   int64_t GetCurrentTime();
 
   // Test only methods
@@ -174,31 +154,11 @@ class PolicyEngine {
 
   LicenseState license_state_;
 
-  // This is the current policy information for this license. This gets updated
-  // as license renewals occur.
-  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::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
-  // license request/renewal
-  int64_t license_start_time_;
-  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_;
-
   // to assist in clock rollback checks
   int64_t last_recorded_current_time_;
 
@@ -210,11 +170,16 @@ class PolicyEngine {
   // and current status (CdmKeyStatus)
   std::unique_ptr<LicenseKeys> license_keys_;
 
+  // This is the current policy information for this license. This gets updated
+  // as license renewals occur.
+  video_widevine::License::Policy policy_;
+
   // Device checks
   int64_t next_device_check_;
   uint32_t current_resolution_;
   CryptoSession* crypto_session_;
 
+  std::unique_ptr<PolicyTimers> policy_timers_;
   std::unique_ptr<Clock> clock_;
 
   CORE_DISALLOW_COPY_AND_ASSIGN(PolicyEngine);