Generalize AesDecryptor to make it more spec compliant.

webkit/media/webmediaplayer_proxy.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_WEBMEDIAPLAYER_PROXY_H_
 #define WEBKIT_MEDIA_WEBMEDIAPLAYER_PROXY_H_
 
 #include <list>
 #include <string>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/lock.h"
 #include "media/base/pipeline.h"
+#include "media/crypto/decryptor_client.h"
 #include "media/filters/chunk_demuxer.h"
 #include "media/filters/chunk_demuxer_client.h"
 #include "media/filters/ffmpeg_video_decoder.h"
 #include "webkit/media/buffered_data_source.h"
 #include "webkit/media/skcanvas_video_renderer.h"
 
 class SkCanvas;
 
 namespace base {
 class MessageLoopProxy;
 }
 
 namespace gfx {
 class Rect;
 }
 
 namespace media {
 class VideoFrame;
 class VideoRendererBase;
 }
 
 namespace webkit_media {
 
 class WebMediaPlayerImpl;
 
 // Acts as a thread proxy between the various threads used for multimedia and
 // the render thread that WebMediaPlayerImpl is running on.
 class WebMediaPlayerProxy
     : public base::RefCountedThreadSafe<WebMediaPlayerProxy>,
-      public media::ChunkDemuxerClient {
+      public media::ChunkDemuxerClient,
+      public media::DecryptorClient {
  public:
   WebMediaPlayerProxy(const scoped_refptr<base::MessageLoopProxy>& render_loop,
                       WebMediaPlayerImpl* webmediaplayer);
   const scoped_refptr<BufferedDataSource>& data_source() {
     return data_source_;
   }
   void set_data_source(const scoped_refptr<BufferedDataSource>& data_source) {
     data_source_ = data_source;
   }
 
@@ skipping 28 matching lines @@
   // Methods for Pipeline -> WebMediaPlayerImpl communication.
   void PipelineInitializationCallback(media::PipelineStatus status);
   void PipelineSeekCallback(media::PipelineStatus status);
   void PipelineEndedCallback(media::PipelineStatus status);
   void PipelineErrorCallback(media::PipelineStatus error);
   void NetworkEventCallback(media::NetworkEvent type);
 
   // ChunkDemuxerClient implementation.
   virtual void DemuxerOpened(media::ChunkDemuxer* demuxer) OVERRIDE;
   virtual void DemuxerClosed() OVERRIDE;
-  virtual void KeyNeeded(scoped_array<uint8> init_data,
-                         int init_data_size) OVERRIDE;
+  virtual void DemuxerKeyNeeded(scoped_array<uint8> init_data,
+                                int init_data_size) OVERRIDE;
 
   // Methods for Demuxer communication.
   void DemuxerStartWaitingForSeek();
   media::ChunkDemuxer::Status DemuxerAddId(const std::string& id,
                                            const std::string& type,
                                            std::vector<std::string>& codecs);
   void DemuxerRemoveId(const std::string& id);
   bool DemuxerBufferedRange(const std::string& id,
                             media::ChunkDemuxer::Ranges* ranges_out);
   bool DemuxerAppend(const std::string& id, const uint8* data, size_t length);
   void DemuxerAbort(const std::string& id);
   void DemuxerEndOfStream(media::PipelineStatus status);
   void DemuxerShutdown();
 
   void DemuxerOpenedTask(const scoped_refptr<media::ChunkDemuxer>& demuxer);
   void DemuxerClosedTask();
-  void KeyNeededTask(scoped_array<uint8> init_data, int init_data_size);
+
+  // 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,
+                        media::AesDecryptor::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 KeyNeeded(const std::string& key_system,
+                         const std::string& session_id,
+                         scoped_array<uint8> init_data,
+                         int init_data_size) OVERRIDE;
+
+  // Methods for DecryptorClient -> WebMediaPlayerImpl communication.

[ddorwin, 2012/06/11 21:02:40]

These should be private, right?

[scherkus (not reviewing), 2012/06/12 03:15:58]

yep

[xhwang, 2012/06/12 19:01:15]

Done.

[xhwang, 2012/06/12 19:01:15]

Done.

+  void KeyAddedTask(const std::string& key_system,
+                    const std::string& session_id);
+  void KeyErrorTask(const std::string& key_system,
+                    const std::string& session_id,
+                    media::AesDecryptor::KeyError error_code,
+                    int system_code);
+  void KeyMessageTask(const std::string& key_system,
+                      const std::string& session_id,
+                      scoped_array<uint8> message,
+                      int message_length,
+                      const std::string& default_url);
+  void KeyNeededTask(const std::string& key_system,
+                     const std::string& session_id,
+                     scoped_array<uint8> init_data,
+                     int init_data_size);
 
  private:
   friend class base::RefCountedThreadSafe<WebMediaPlayerProxy>;
   virtual ~WebMediaPlayerProxy();
 
   // Invoke |webmediaplayer_| to perform a repaint.
   void RepaintTask();
 
   // Notify |webmediaplayer_| that initialization has finished.
   void PipelineInitializationTask(media::PipelineStatus status);
@@ skipping 27 matching lines @@
   int outstanding_repaints_;
 
   scoped_refptr<media::ChunkDemuxer> chunk_demuxer_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(WebMediaPlayerProxy);
 };
 
 }  // namespace webkit_media
 
 #endif  // WEBKIT_MEDIA_WEBMEDIAPLAYER_PROXY_H_