Update Pepper interface for EME

content/renderer/pepper/content_decryptor_delegate.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 CONTENT_RENDERER_PEPPER_CONTENT_DECRYPTOR_DELEGATE_H_
 #define CONTENT_RENDERER_PEPPER_CONTENT_DECRYPTOR_DELEGATE_H_
 
 #include <map>
 #include <queue>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/callback_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "media/base/cdm_promise.h"
 #include "media/base/channel_layout.h"
 #include "media/base/decryptor.h"
 #include "media/base/media_keys.h"
 #include "media/base/sample_format.h"
+#include "ppapi/c/pp_time.h"
 #include "ppapi/c/private/pp_content_decryptor.h"
 #include "ppapi/c/private/ppp_content_decryptor_private.h"
 #include "ui/gfx/size.h"
 
 namespace media {
 class AudioDecoderConfig;
 class DecoderBuffer;
 class VideoDecoderConfig;
 }
 
@@ skipping 15 matching lines @@
   void Initialize(const std::string& key_system,
                   const media::SessionMessageCB& session_message_cb,
                   const media::SessionReadyCB& session_ready_cb,
                   const media::SessionClosedCB& session_closed_cb,
                   const media::SessionErrorCB& session_error_cb,
                   const base::Closure& fatal_plugin_error_cb);
 
   void InstanceCrashed();
 
   // Provides access to PPP_ContentDecryptor_Private.
+  void SetServerCertificate(const uint8* certificate,
+                            int certificate_length,
+                            scoped_ptr<media::SimpleCdmPromise> promise);
   void CreateSession(const std::string& init_data_type,
                      const uint8* init_data,
                      int init_data_length,
                      media::MediaKeys::SessionType session_type,
                      scoped_ptr<media::NewSessionCdmPromise> promise);
   void LoadSession(const std::string& web_session_id,
                    scoped_ptr<media::NewSessionCdmPromise> promise);
   void UpdateSession(const std::string& web_session_id,
                      const uint8* response,
                      int response_length,
                      scoped_ptr<media::SimpleCdmPromise> promise);
-  void ReleaseSession(const std::string& web_session_id,
-                      scoped_ptr<media::SimpleCdmPromise> promise);
+  void GetUsableKeyIds(const std::string& web_session_id,

[ddorwin, 2014/08/22 20:49:20]

Nit: Keep the lifetime methods together, meaning this should be after Remove.

[jrummell, 2014/08/25 21:54:36]

Done.

+                       scoped_ptr<media::KeyIdsPromise> promise);
+  void CloseSession(const std::string& web_session_id,
+                    scoped_ptr<media::SimpleCdmPromise> promise);
+  void RemoveSession(const std::string& web_session_id,
+                     scoped_ptr<media::SimpleCdmPromise> promise);
   bool Decrypt(media::Decryptor::StreamType stream_type,
                const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
                const media::Decryptor::DecryptCB& decrypt_cb);
   bool CancelDecrypt(media::Decryptor::StreamType stream_type);
   bool InitializeAudioDecoder(
       const media::AudioDecoderConfig& decoder_config,
       const media::Decryptor::DecoderInitCB& decoder_init_cb);
   bool InitializeVideoDecoder(
       const media::VideoDecoderConfig& decoder_config,
       const media::Decryptor::DecoderInitCB& decoder_init_cb);
   // TODO(tomfinegan): Add callback args for DeinitializeDecoder() and
   // ResetDecoder()
   bool DeinitializeDecoder(media::Decryptor::StreamType stream_type);
   bool ResetDecoder(media::Decryptor::StreamType stream_type);
   // Note: These methods can be used with unencrypted data.
   bool DecryptAndDecodeAudio(
       const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
       const media::Decryptor::AudioDecodeCB& audio_decode_cb);
   bool DecryptAndDecodeVideo(
       const scoped_refptr<media::DecoderBuffer>& encrypted_buffer,
       const media::Decryptor::VideoDecodeCB& video_decode_cb);
 
   // PPB_ContentDecryptor_Private dispatching methods.
   void OnPromiseResolved(uint32 promise_id);
   void OnPromiseResolvedWithSession(uint32 promise_id, PP_Var web_session_id);
+  void OnPromiseResolvedWithKeyIds(uint32 promise_id, PP_Var key_ids);
   void OnPromiseRejected(uint32 promise_id,
                          PP_CdmExceptionCode exception_code,
                          uint32 system_code,
                          PP_Var error_description);
   void OnSessionMessage(PP_Var web_session_id,
                         PP_Var message,
                         PP_Var destination_url);
+  void OnSessionKeysChange(PP_Var web_session_id,
+                           PP_Bool has_additional_usable_key);
+  void OnSessionExpirationChange(PP_Var web_session_id,
+                                 PP_Time new_expiry_time);
   void OnSessionReady(PP_Var web_session_id);
   void OnSessionClosed(PP_Var web_session_id);
   void OnSessionError(PP_Var web_session_id,
                       PP_CdmExceptionCode exception_code,
                       uint32 system_code,
                       PP_Var error_description);
   void DeliverBlock(PP_Resource decrypted_block,
                     const PP_DecryptedBlockInfo* block_info);
   void DecoderInitializeDone(PP_DecryptorStreamType decoder_type,
                              uint32_t request_id,
@@ skipping 130 matching lines @@
 
   base::WeakPtr<ContentDecryptorDelegate> weak_this_;
   base::WeakPtrFactory<ContentDecryptorDelegate> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentDecryptorDelegate);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_PEPPER_CONTENT_DECRYPTOR_DELEGATE_H_