Generalize AesDecryptor to make it more spec compliant.

webkit/media/webmediaplayer_impl.cc

 // 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.
 
 #include "webkit/media/webmediaplayer_impl.h"
 
 #include <limits>
 #include <string>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "media/audio/null_audio_sink.h"
 #include "media/base/filter_collection.h"
@@ skipping 131 matching lines @@
           base::Bind(&WebMediaPlayerProxy::SetOpaque, proxy_.get()),
           true);
   filter_collection_->AddVideoRenderer(video_renderer);
   proxy_->set_frame_provider(video_renderer);
 
   // Create default audio renderer.
   filter_collection_->AddAudioRenderer(
       new media::AudioRendererImpl(new media::NullAudioSink()));
 
   decryptor_.reset(new media::AesDecryptor());
+  decryptor_->Init(proxy_.get());
 }
 
 WebMediaPlayerImpl::~WebMediaPlayerImpl() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   Destroy();
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_DESTROYED));
 
   if (delegate_)
     delegate_->PlayerGone(this);
@@ skipping 522 matching lines @@
 bool WebMediaPlayerImpl::sourceAbort(const WebKit::WebString& id) {
   proxy_->DemuxerAbort(id.utf8().data());
   return true;
 }
 
 void WebMediaPlayerImpl::sourceEndOfStream(
     WebMediaPlayer::EndOfStreamStatus status) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   media::PipelineStatus pipeline_status = media::PIPELINE_OK;
 
-  switch(status) {
+  switch (status) {
     case WebMediaPlayer::EndOfStreamStatusNoError:
       break;
     case WebMediaPlayer::EndOfStreamStatusNetworkError:
       pipeline_status = media::PIPELINE_ERROR_NETWORK;
       break;
     case WebMediaPlayer::EndOfStreamStatusDecodeError:
       pipeline_status = media::PIPELINE_ERROR_DECODE;
       break;
     default:
       NOTIMPLEMENTED();
   }
 
   proxy_->DemuxerEndOfStream(pipeline_status);
 }
 
 WebKit::WebMediaPlayer::MediaKeyException
 WebMediaPlayerImpl::generateKeyRequest(const WebString& key_system,
                                        const unsigned char* init_data,
                                        unsigned init_data_length) {
   if (!IsSupportedKeySystem(key_system))
     return WebKit::WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
 
-  // Every request call creates a unique ID.
-  // TODO(ddorwin): Move this to the CDM implementations since the CDMs may
-  // create their own IDs and since CDMs supporting multiple renderer processes
-  // need globally unique IDs.
-  // Everything from here until the return should probably be handled by
-  // the decryptor - see http://crbug.com/123260.
-  static uint32_t next_available_session_id = 1;
-  uint32_t session_id = next_available_session_id++;
-
-  WebString session_id_string(base::UintToString16(session_id));
-
   DVLOG(1) << "generateKeyRequest: " << key_system.utf8().data() << ": "
            << std::string(reinterpret_cast<const char*>(init_data),
-                          static_cast<size_t>(init_data_length))
-           << " [" << session_id_string.utf8().data() << "]";
+                          static_cast<size_t>(init_data_length));
 
-  // TODO(ddorwin): Generate a key request in the decryptor and fire
-  // keyMessage when it completes.
-  // For now, just fire the event with the init_data as the request.
-  const unsigned char* message = init_data;
-  unsigned message_length = init_data_length;
-
-  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-      &WebKit::WebMediaPlayerClient::keyMessage,
-      base::Unretained(GetClient()),
-      key_system,
-      session_id_string,
-      message,
-      message_length));
-
+  decryptor_->GenerateKeyRequest(key_system.utf8(),

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

At some point, we will need to post these operations to another thread. Not sure
where.

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

I suppose these key operations called on the renderer thread are all
light-weighted. This is true for AesDecryptor now. For the future CDM, I'd
expect these calls to send an IPC to the plugin process and return, which should
be pretty fast. Make extra comments about this in aes_decryptor.h

+                                 init_data, init_data_length);
   return WebKit::WebMediaPlayer::MediaKeyExceptionNoError;
 }
 
 WebKit::WebMediaPlayer::MediaKeyException WebMediaPlayerImpl::addKey(
     const WebString& key_system,
     const unsigned char* key,
     unsigned key_length,
     const unsigned char* init_data,
     unsigned init_data_length,
     const WebString& session_id) {
   DCHECK(key);
   DCHECK_GT(key_length, 0u);
 
   if (!IsSupportedKeySystem(key_system))
     return WebKit::WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
 
-
   DVLOG(1) << "addKey: " << key_system.utf8().data() << ": "
            << std::string(reinterpret_cast<const char*>(key),
                           static_cast<size_t>(key_length)) << ", "
            << std::string(reinterpret_cast<const char*>(init_data),
                           static_cast<size_t>(init_data_length))
            << " [" << session_id.utf8().data() << "]";
 
-  // TODO(ddorwin): Everything from here until the return should probably be
-  // handled by the decryptor - see http://crbug.com/123260.
-  // Temporarily, fire an error for invalid key length so we can test the error
-  // event and fire the keyAdded event in all other cases.
-  const unsigned kSupportedKeyLength = 16;  // 128-bit key.
-  if (key_length != kSupportedKeyLength) {
-    DLOG(ERROR) << "addKey: invalid key length: " << key_length;
-    MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-        &WebKit::WebMediaPlayerClient::keyError,
-        base::Unretained(GetClient()),
-        key_system,
-        session_id,
-        WebKit::WebMediaPlayerClient::MediaKeyErrorCodeUnknown,
-        0));
-  } else {
-    // TODO(ddorwin): Fix the decryptor to accept no |init_data|. See
-    // http://crbug.com/123265. Until then, ensure a non-empty value is passed.
-    static const unsigned char kDummyInitData[1] = {0};
-    if (!init_data) {
-      init_data = kDummyInitData;
-      init_data_length = arraysize(kDummyInitData);
-    }
-
-    decryptor_->AddKey(init_data, init_data_length, key, key_length);
-
-    MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-        &WebKit::WebMediaPlayerClient::keyAdded,
-        base::Unretained(GetClient()),
-        key_system,
-        session_id));
-  }
-
+  decryptor_->AddKey(key_system.utf8(), init_data, init_data_length,
+                     key, key_length, session_id.utf8());
   return WebKit::WebMediaPlayer::MediaKeyExceptionNoError;
 }
 
 WebKit::WebMediaPlayer::MediaKeyException WebMediaPlayerImpl::cancelKeyRequest(
     const WebString& key_system,
     const WebString& session_id) {
   if (!IsSupportedKeySystem(key_system))
     return WebKit::WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
 
-  // TODO(ddorwin): Cancel the key request in the decryptor.
-
+  decryptor_->CancelKeyRequest(key_system.utf8(), session_id.utf8());
   return WebKit::WebMediaPlayer::MediaKeyExceptionNoError;
 }
 
 void WebMediaPlayerImpl::WillDestroyCurrentMessageLoop() {
   Destroy();
   main_loop_ = NULL;
 }
 
 void WebMediaPlayerImpl::Repaint() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
@@ skipping 92 matching lines @@
       SetNetworkState(WebMediaPlayer::NetworkStateDecodeError);
       break;
   }
 
   // Repaint to trigger UI update.
   Repaint();
 }
 
 void WebMediaPlayerImpl::OnNetworkEvent(NetworkEvent type) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
-  switch(type) {
+  switch (type) {
     case media::DOWNLOAD_CONTINUED:
       SetNetworkState(WebMediaPlayer::NetworkStateLoading);
       break;
     case media::DOWNLOAD_PAUSED:
       SetNetworkState(WebMediaPlayer::NetworkStateIdle);
       break;
     case media::CAN_PLAY_THROUGH:
       // Temporarily disable delayed firing of CAN_PLAY_THROUGH due to
       // crbug.com/106480.
       // TODO(vrk): uncomment code below when bug above is fixed.
       // SetReadyState(WebMediaPlayer::NetworkStateHaveEnoughData);
       break;
     default:
       NOTREACHED();
   }
 }
 
 void WebMediaPlayerImpl::OnDemuxerOpened() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
 
   GetClient()->sourceOpened();
 }
 
-void WebMediaPlayerImpl::OnKeyNeeded(scoped_array<uint8> init_data,
+void WebMediaPlayerImpl::OnKeyAdded(const std::string& key_system,
+                                    const std::string& session_id) {
+  DCHECK_EQ(main_loop_, MessageLoop::current());
+
+  GetClient()->keyAdded(WebString::fromUTF8(key_system),
+                        WebString::fromUTF8(session_id));
+}
+
+void WebMediaPlayerImpl::OnKeyNeeded(const std::string& key_system,
+                                     const std::string& session_id,
+                                     scoped_array<uint8> init_data,
                                      int init_data_size) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
 
-  GetClient()->keyNeeded("", "", init_data.get(), init_data_size);
+  GetClient()->keyNeeded(WebString::fromUTF8(key_system),
+                         WebString::fromUTF8(session_id),
+                         init_data.get(),
+                         init_data_size);
+}
+
+void WebMediaPlayerImpl::OnKeyError(const std::string& key_system,
+                                    const std::string& session_id,
+                                    media::AesDecryptor::KeyError error_code,
+                                    int system_code) {
+  DCHECK_EQ(main_loop_, MessageLoop::current());
+
+  GetClient()->keyError(
+      WebString::fromUTF8(key_system),
+      WebString::fromUTF8(session_id),
+      static_cast<WebKit::WebMediaPlayerClient::MediaKeyErrorCode>(error_code),
+      system_code);
+}
+
+void WebMediaPlayerImpl::OnKeyMessage(const std::string& key_system,
+                                      const std::string& session_id,
+                                      scoped_array<uint8> message,
+                                      int message_length,
+                                      const std::string& /* default_url */) {
+  DCHECK_EQ(main_loop_, MessageLoop::current());
+
+  GetClient()->keyMessage(WebString::fromUTF8(key_system),
+                          WebString::fromUTF8(session_id),
+                          message.get(),
+                          message_length);
 }
 
 void WebMediaPlayerImpl::SetOpaque(bool opaque) {
   DCHECK_EQ(main_loop_, MessageLoop::current());
 
   GetClient()->setOpaque(opaque);
 }
 
 void WebMediaPlayerImpl::DataSourceInitialized(
     const GURL& gurl,
@@ skipping 83 matching lines @@
   return audio_source_provider_;
 }
 
 void WebMediaPlayerImpl::IncrementExternallyAllocatedMemory() {
   DCHECK_EQ(main_loop_, MessageLoop::current());
   incremented_externally_allocated_memory_ = true;
   v8::V8::AdjustAmountOfExternalAllocatedMemory(kPlayerExtraMemory);
 }
 
 }  // namespace webkit_media