Encrypted Media: Replace DecryptorClient with key event callbacks.

webkit/media/crypto/proxy_decryptor.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 WEBKIT_MEDIA_CRYPTO_PROXY_DECRYPTOR_H_
 #define WEBKIT_MEDIA_CRYPTO_PROXY_DECRYPTOR_H_
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "media/base/decryptor.h"
+#include "media/base/decryptor_client.h"
 
 namespace base {
 class MessageLoopProxy;
 }
 
 namespace media {
 class DecryptorClient;
 }
 
 namespace WebKit {
 class WebFrame;
 class WebMediaPlayerClient;
 }
 
 namespace webkit_media {
 
 // A decryptor proxy that creates a real decryptor object on demand and
 // forwards decryptor calls to it.
 // TODO(xhwang): Currently we don't support run-time switching among decryptor
 // objects. Fix this when needed.
-class ProxyDecryptor : public media::Decryptor {
+class ProxyDecryptor : public media::Decryptor, public media::DecryptorClient {
  public:
+  typedef base::Callback<void(const std::string& key_system,
+                              const std::string& session_id)> KeyAddedCB;
+  typedef base::Callback<void(const std::string& key_system,
+                              const std::string& session_id,
+                              media::Decryptor::KeyError error_code,
+                              int system_code)> KeyErrorCB;
+  typedef base::Callback<void(const std::string& key_system,
+                              const std::string& session_id,
+                              scoped_array<uint8> message,
+                              int message_length,
+                              const std::string& default_url)> KeyMessageCB;
+  typedef base::Callback<void(const std::string& key_system,
+                              const std::string& session_id,
+                              scoped_array<uint8> init_data,
+                              int init_data_size)> NeedKeyCB;

[Ami GONE FROM CHROMIUM, 2012/10/23 06:52:22]

ISTM this CL went half-way to the real goal: delete DecryptorClient and put
these typedefs in Decryptor.  Maybe that's what you meant in one of your
discussion points?
Anyway, I think that'd be best.

[xhwang, 2012/10/23 07:32:13]

Agreed that if we choose the pure callback path then these CBs should be defined
somewhere else (e.g. Decryptor).

+
   ProxyDecryptor(const scoped_refptr<base::MessageLoopProxy>& message_loop,
-                 media::DecryptorClient* decryptor_client,
+                 const KeyAddedCB& key_added_cb,
+                 const KeyErrorCB& key_error_cb,
+                 const KeyMessageCB& key_message_cb,
+                 const NeedKeyCB& need_key_cb,
                  WebKit::WebMediaPlayerClient* web_media_player_client,
                  WebKit::WebFrame* web_frame);
   virtual ~ProxyDecryptor();
 
   void set_decryptor_for_testing(scoped_ptr<media::Decryptor> decryptor) {
     decryptor_ = decryptor.Pass();
   }
 
   // Callback to notify that the decryptor has been created.
   typedef base::Callback<void(Decryptor*)> DecryptorNotificationCB;
@@ skipping 31 matching lines @@
       const KeyAddedCB& key_added_cb) OVERRIDE;
   virtual void DecryptAndDecodeAudio(
       const scoped_refptr<media::DecoderBuffer>& encrypted,
       const AudioDecodeCB& audio_decode_cb) OVERRIDE;
   virtual void DecryptAndDecodeVideo(
       const scoped_refptr<media::DecoderBuffer>& encrypted,
       const VideoDecodeCB& video_decode_cb) OVERRIDE;
   virtual void ResetDecoder(StreamType stream_type) OVERRIDE;
   virtual void DeinitializeDecoder(StreamType stream_type) OVERRIDE;
 
+  // media::DecryptorClient implementation.
+  virtual void KeyAdded(const std::string& key_system,
+                        const std::string& session_id) OVERRIDE;
+  virtual void KeyError(const std::string& key_system,
+                        const std::string& session_id,
+                        Decryptor::KeyError error_code,
+                        int system_code) OVERRIDE;
+  virtual void KeyMessage(const std::string& key_system,
+                          const std::string& session_id,
+                          scoped_array<uint8> message,
+                          int message_length,
+                          const std::string& default_url) OVERRIDE;
+  virtual void NeedKey(const std::string& key_system,
+                       const std::string& session_id,
+                       scoped_array<uint8> init_data,
+                       int init_data_length) OVERRIDE;
+
  private:
   // Helper functions to create decryptors to handle the given |key_system|.
   scoped_ptr<media::Decryptor> CreatePpapiDecryptor(
       const std::string& key_system);
   scoped_ptr<media::Decryptor> CreateDecryptor(const std::string& key_system);
 
   void OnNewKeyAdded();
 
   // Sends |pending_buffer_to_decrypt_| to |decryptor_| for decryption.
   void DecryptPendingBuffer();
 
   // Callback passed to decryptor_->Decrypt(). It processes the |status| and
   // |decrypted| buffer from the |decryptor_|.
   void OnBufferDecrypted(media::Decryptor::Status status,
                          const scoped_refptr<media::DecoderBuffer>& decrypted);
 
   // Message loop on which decryption-related methods happen. Note that
   // key/session-related methods do not run on this message loop.
   scoped_refptr<base::MessageLoopProxy> const decryption_message_loop_;
 
-  // DecryptorClient through which key events are fired.
-  media::DecryptorClient* client_;
+  // Callbacks for firing key events.
+  KeyAddedCB key_added_cb_;
+  KeyErrorCB key_error_cb_;
+  KeyMessageCB key_message_cb_;
+  NeedKeyCB need_key_cb_;
 
   // Needed to create the PpapiDecryptor.
   WebKit::WebMediaPlayerClient* web_media_player_client_;
   WebKit::WebFrame* web_frame_;
 
   // Protects the |decryptor_|. Note that |decryptor_| itself should be thread
   // safe as per the Decryptor interface.
   base::Lock lock_;
 
   DecryptorNotificationCB decryptor_notification_cb_;
@@ skipping 25 matching lines @@
   // the |pending_buffer_to_decrypt_| again if kNoKey is returned because a
   // new key has been added.
   bool has_new_key_added_;
 
   DISALLOW_COPY_AND_ASSIGN(ProxyDecryptor);
 };
 
 }  // namespace webkit_media
 
 #endif  // WEBKIT_MEDIA_CRYPTO_PROXY_DECRYPTOR_H_