Add Promises for EME (Chromium side)

content/renderer/media/android/proxy_media_keys.h

 // Copyright 2013 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_MEDIA_ANDROID_PROXY_MEDIA_KEYS_H_
 #define CONTENT_RENDERER_MEDIA_ANDROID_PROXY_MEDIA_KEYS_H_
 
+#include <map>
+#include <string>
+
 #include "base/basictypes.h"
 #include "media/base/media_keys.h"
 
 class GURL;
 
 namespace content {
 
 class RendererMediaPlayerManager;
 
 // A MediaKeys proxy that wraps the EME part of RendererMediaPlayerManager.
 // TODO(xhwang): Instead of accessing RendererMediaPlayerManager directly, let
 // RendererMediaPlayerManager return a MediaKeys object that can be used by
 // ProxyDecryptor directly. Then we can remove this class!
 class ProxyMediaKeys : public media::MediaKeys {
  public:
   static scoped_ptr<ProxyMediaKeys> Create(
       const std::string& key_system,
       const GURL& security_origin,
       RendererMediaPlayerManager* manager,
-      const media::SessionCreatedCB& session_created_cb,
       const media::SessionMessageCB& session_message_cb,
       const media::SessionReadyCB& session_ready_cb,
       const media::SessionClosedCB& session_closed_cb,
       const media::SessionErrorCB& session_error_cb);
 
   virtual ~ProxyMediaKeys();
 
   // MediaKeys implementation.
-  virtual bool CreateSession(uint32 session_id,
-                             const std::string& content_type,
-                             const uint8* init_data,
-                             int init_data_length) OVERRIDE;
-  virtual void LoadSession(uint32 session_id,
-                           const std::string& web_session_id) OVERRIDE;
-  virtual void UpdateSession(uint32 session_id,
-                             const uint8* response,
-                             int response_length) OVERRIDE;
-  virtual void ReleaseSession(uint32 session_id) OVERRIDE;
+  virtual void CreateSession(
+      const std::string& init_data_type,
+      const uint8* init_data,
+      int init_data_length,
+      SessionType session_type,
+      scoped_ptr<media::MediaKeysSessionPromise> promise) OVERRIDE;

[xhwang, 2014/05/05 20:46:42]

Now "cdm" is the standard term in chromium and MediaKeys should only live in
Blink. (We have "MediaKeys" for historical reasons but we plan to remove them.
See http://crbug.com/309237).

Also, I am not sure about "MediaKeysSession". It's not "MediaKeys", nor
"MediaKeySession". Do you mean that this class can be used by both MediaKeys
(for createSession()) and MediaKeySession (for update() etc)?

Maybe we should just use CdmPromise here, which will handle all kinds of
Promises used in the CDM (as in spec) implementation. WDYT?

+  virtual void LoadSession(
+      const std::string& web_session_id,
+      scoped_ptr<media::MediaKeysSessionPromise> promise) OVERRIDE;
+  virtual void UpdateSession(
+      const std::string& web_session_id,
+      const uint8* response,
+      int response_length,
+      scoped_ptr<media::MediaKeysSessionPromise> promise) OVERRIDE;
+  virtual void ReleaseSession(
+      const std::string& web_session_id,
+      scoped_ptr<media::MediaKeysSessionPromise> promise) OVERRIDE;
 
   // Callbacks.
   void OnSessionCreated(uint32 session_id, const std::string& web_session_id);
   void OnSessionMessage(uint32 session_id,
                         const std::vector<uint8>& message,
                         const std::string& destination_url);
   void OnSessionReady(uint32 session_id);
   void OnSessionClosed(uint32 session_id);
   void OnSessionError(uint32 session_id,
                       media::MediaKeys::KeyError error_code,
                       uint32 system_code);
 
   int GetCdmId() const;
 
  private:
   ProxyMediaKeys(RendererMediaPlayerManager* manager,
-                 const media::SessionCreatedCB& session_created_cb,
                  const media::SessionMessageCB& session_message_cb,
                  const media::SessionReadyCB& session_ready_cb,
                  const media::SessionClosedCB& session_closed_cb,
                  const media::SessionErrorCB& session_error_cb);
 
   void InitializeCdm(const std::string& key_system,
                      const GURL& security_origin);
 
+  // Helper functions to keep track of session_ids <-> web_session_ids.

[xhwang, 2014/05/05 20:46:42]

Please add a comment that we are still keeping SessionIds for xxx reasons. And
add a TODO to remove them.

[jrummell, 2014/05/08 23:37:45]

Done.

+  uint32_t CreateSessionId();
+  void AssignWebSessionId(uint32_t session_id,
+                          const std::string& web_session_id);
+  uint32_t LookupSessionId(const std::string& web_session_id);
+  std::string LookupWebSessionId(uint32_t session_id);
+  void DropWebSessionId(std::string web_session_id);
+
+  // Helper function to keep track of promises. Adding takes ownership of the
+  // promise, transferred back to caller on lookup.
+  void AddPromise(uint32_t session_id,

[xhwang, 2014/05/05 20:46:42]

To be consistent to CdmSessionAdapter, how about RegisterPromise()?

[jrummell, 2014/05/08 23:37:45]

Done.

+                  scoped_ptr<media::MediaKeysSessionPromise> promise);
+  scoped_ptr<media::MediaKeysSessionPromise> LookupPromise(uint32_t session_id);

[xhwang, 2014/05/05 20:46:42]

"Lookup" usually is a const operation, but this isn't. How about
RetrievePromise?

[jrummell, 2014/05/08 23:37:45]

Done.

+
   // CDM ID should be unique per renderer process.
   // TODO(xhwang): Use uint32 to prevent undefined overflow behavior.
   static int next_cdm_id_;
 
   RendererMediaPlayerManager* manager_;
   int cdm_id_;
-  media::SessionCreatedCB session_created_cb_;
   media::SessionMessageCB session_message_cb_;
   media::SessionReadyCB session_ready_cb_;
   media::SessionClosedCB session_closed_cb_;
   media::SessionErrorCB session_error_cb_;
 
+  uint32_t next_session_id_;
+  std::map<std::string, uint32_t> web_session_to_session_id_map_;

[xhwang, 2014/05/05 20:46:42]

Since we use string as the key, use hash_map for better performance.

[jrummell, 2014/05/08 23:37:45]

Done.

+  std::map<uint32_t, media::MediaKeysSessionPromise*>
+      session_id_to_promise_map_;

[xhwang, 2014/05/05 20:46:42]

Please comment that this map owns the promises.

[jrummell, 2014/05/08 23:37:45]

Done.

+
   DISALLOW_COPY_AND_ASSIGN(ProxyMediaKeys);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_MEDIA_ANDROID_PROXY_MEDIA_KEYS_H_