Add LoadSession() to CDM_4.

content_decryption_module.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CDM_CONTENT_DECRYPTION_MODULE_H_
 #define CDM_CONTENT_DECRYPTION_MODULE_H_
 
 #if defined(_MSC_VER)
 typedef unsigned char uint8_t;
 typedef unsigned int uint32_t;
@@ skipping 63 matching lines @@
 }
 
 namespace cdm {
 
 class AudioFrames_1;
 class AudioFrames_2;
 typedef AudioFrames_2 AudioFrames;
 
 class Host_1;
 class Host_2;
-class Host_3;
+class Host_4;
 
 class DecryptedBlock;
 class VideoFrame;
 
 enum Status {
   kSuccess = 0,
   kNeedMoreData,  // Decoder needs more data to produce a decoded frame/sample.
   kNoKey,  // The required decryption key is not available.
   kSessionError,  // Session management error.
   kDecryptError,  // Decryption failed.
@@ skipping 561 matching lines @@
   ContentDecryptionModule_2() {}
   virtual ~ContentDecryptionModule_2() {}
 };
 
 // ContentDecryptionModule interface that all CDMs need to implement.
 // The interface is versioned for backward compatibility.
 // Note: ContentDecryptionModule implementations must use the allocator
 // provided in CreateCdmInstance() to allocate any Buffer that needs to
 // be passed back to the caller. Implementations must call Buffer::Destroy()
 // when a Buffer is created that will never be returned to the caller.
-class ContentDecryptionModule_3 {
+class ContentDecryptionModule_4 {
  public:
-  static const int kVersion = 3;
-  typedef Host_3 Host;
+  static const int kVersion = 4;
+  typedef Host_4 Host;
 
   // CreateSession(), UpdateSession(), and ReleaseSession() get passed a
   // |session_id| for a MediaKeySession object. It must be used in the reply via
   // Host methods (e.g. Host::OnSessionMessage()).
   // Note: |session_id| is different from MediaKeySession's sessionId attribute,
   // which is referred to as |web_session_id| in this file.
 
   // Creates a session given |type| and |init_data|.
   virtual void CreateSession(
       uint32_t session_id,
       const char* type, uint32_t type_size,
       const uint8_t* init_data, uint32_t init_data_size) = 0;
 
+  // Loads a session that has |web_session_id|.
+  virtual void LoadSession(
+      uint32_t session_id,
+      const char* web_session_id, uint32_t web_session_id_length) = 0;
+
   // Updates the session with |response|.
   virtual void UpdateSession(
       uint32_t session_id,
       const uint8_t* response, uint32_t response_size) = 0;
 
   // Releases the resources for the session.
   virtual void ReleaseSession(uint32_t session_id) = 0;
 
   // Performs scheduled operation with |context| when the timer fires.
   virtual void TimerExpired(void* context) = 0;
@@ skipping 93 matching lines @@
   // Called by the host after a call to Host::QueryOutputProtectionStatus(). The
   // |link_mask| is a bit mask of OutputLinkTypes and |output_protection_mask|
   // is a bit mask of OutputProtectionMethods.
   virtual void OnQueryOutputProtectionStatus(
       uint32_t link_mask, uint32_t output_protection_mask) = 0;
 
   // Destroys the object in the same context as it was created.
   virtual void Destroy() = 0;
 
  protected:
-  ContentDecryptionModule_3() {}
-  virtual ~ContentDecryptionModule_3() {}
+  ContentDecryptionModule_4() {}
+  virtual ~ContentDecryptionModule_4() {}
 };
 
-typedef ContentDecryptionModule_3 ContentDecryptionModule;
+typedef ContentDecryptionModule_4 ContentDecryptionModule;
 
 // Represents a buffer created by Allocator implementations.
 class Buffer {
  public:
   // Destroys the buffer in the same context as it was created.
   virtual void Destroy() = 0;
 
   virtual uint32_t Capacity() const = 0;
   virtual uint8_t* Data() = 0;
   virtual void SetSize(uint32_t size) = 0;
@@ skipping 109 matching lines @@
   // Must be called by the CDM if it returned kDeferredInitialization during
   // InitializeAudioDecoder() or InitializeVideoDecoder().
   virtual void OnDeferredInitializationDone(StreamType stream_type,
                                             Status decoder_status) = 0;
 
  protected:
   Host_2() {}
   virtual ~Host_2() {}
 };
 
-class Host_3 {
+class Host_4 {
  public:
-  static const int kVersion = 3;
+  static const int kVersion = 4;
 
   // Returns a Buffer* containing non-zero members upon success, or NULL on
   // failure. The caller owns the Buffer* after this call. The buffer is not
   // guaranteed to be zero initialized. The capacity of the allocated Buffer
   // is guaranteed to be not less than |capacity|.
   virtual Buffer* Allocate(uint32_t capacity) = 0;
 
   // Requests the host to call ContentDecryptionModule::TimerFired() |delay_ms|
   // from now with |context|.
   virtual void SetTimer(int64_t delay_ms, void* context) = 0;
 
   // Returns the current epoch wall time in seconds.
   virtual double GetCurrentWallTimeInSeconds() = 0;
 
-  // Called by the CDM when a session is created and the value for the
+  // Called by the CDM when a session is created or loaded and the value for the
   // MediaKeySession's sessionId attribute is available (|web_session_id|).
   // This must be called before OnSessionMessage() or OnSessionReady() is called
   // for |session_id|. |web_session_id_length| should not include null
   // termination.
+  // When called in response to LoadSession(), the |web_session_id| must be the
+  // same as the |web_session_id| passed in LoadSession().
   virtual void OnSessionCreated(
       uint32_t session_id,
       const char* web_session_id, uint32_t web_session_id_length) = 0;
 
   // Called by the CDM when it has a message for session |session_id|.
   // Length parameters should not include null termination.
   virtual void OnSessionMessage(
       uint32_t session_id,
       const char* message, uint32_t message_length,
       const char* destination_url, uint32_t destination_url_length) = 0;
 
   // Called by the CDM when session |session_id| is ready.
+  // Note: "ready" event is deprecated. This is only used for the prefixed EME
+  // API's "keyAdded" event. Drop this when we deprecate prefixed EME API.
   virtual void OnSessionReady(uint32_t session_id) = 0;
 
   // Called by the CDM when session |session_id| is closed.
   virtual void OnSessionClosed(uint32_t session_id) = 0;
 
   // Called by the CDM when an error occurs in session |session_id|.
   virtual void OnSessionError(uint32_t session_id,
                               MediaKeyError error_code,
                               uint32_t system_code) = 0;
 
@@ skipping 24 matching lines @@
   virtual void OnDeferredInitializationDone(StreamType stream_type,
                                             Status decoder_status) = 0;
 
   // Creates a FileIO object from the host to do file IO operation. Returns NULL
   // if a FileIO object cannot be obtained. Once a valid FileIO object is
   // returned, |client| must be valid until FileIO::Close() is called. The
   // CDM can call this method multiple times to operate on different files.
   virtual FileIO* CreateFileIO(FileIOClient* client) = 0;
 
  protected:
-  Host_3() {}
-  virtual ~Host_3() {}
+  Host_4() {}
+  virtual ~Host_4() {}
 };
 
 // Represents a decrypted block that has not been decoded.
 class DecryptedBlock {
  public:
   virtual void SetDecryptedBuffer(Buffer* buffer) = 0;
   virtual Buffer* DecryptedBuffer() = 0;
 
   // TODO(tomfinegan): Figure out if timestamp is really needed. If it is not,
   // we can just pass Buffer pointers around.
@@ skipping 75 matching lines @@
   virtual AudioFormat Format() const = 0;
 
  protected:
   AudioFrames_2() {}
   virtual ~AudioFrames_2() {}
 };
 
 }  // namespace cdm
 
 #endif  // CDM_CONTENT_DECRYPTION_MODULE_H_