Update ClearKey to support CDM_6

content/renderer/media/crypto/ppapi_decryptor.cc

 // 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.
 
 #include "content/renderer/media/crypto/ppapi_decryptor.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 37 matching lines @@
     DCHECK(is_pending_);
     is_pending_ = false;
     caller_promise_->reject(exception_code, system_code, error_message);
   }
 
  protected:
   scoped_ptr<media::SimpleCdmPromise> caller_promise_;
   base::Closure additional_resolve_cb_;
 };
 
+// This class is needed so that resolving a SessionLoaded() promise triggers
+// playback of the stream. It intercepts the resolve() call to invoke an
+// additional callback. This is only needed until KeysChange event gets passed
+// through Pepper.
+class SessionLoadedPromise : public media::NewSessionCdmPromise {
+ public:
+  SessionLoadedPromise(scoped_ptr<media::NewSessionCdmPromise> caller_promise,
+                       base::Closure additional_resolve_cb)
+      : caller_promise_(caller_promise.Pass()),
+        additional_resolve_cb_(additional_resolve_cb) {}
+
+  virtual void resolve(const std::string& web_session_id) OVERRIDE {
+    DCHECK(is_pending_);
+    is_pending_ = false;
+    additional_resolve_cb_.Run();
+    caller_promise_->resolve(web_session_id);
+  }
+
+  virtual void reject(media::MediaKeys::Exception exception_code,
+                      uint32 system_code,
+                      const std::string& error_message) OVERRIDE {
+    DCHECK(is_pending_);
+    is_pending_ = false;
+    caller_promise_->reject(exception_code, system_code, error_message);
+  }
+
+ protected:
+  scoped_ptr<media::NewSessionCdmPromise> caller_promise_;
+  base::Closure additional_resolve_cb_;
+};
+
 scoped_ptr<PpapiDecryptor> PpapiDecryptor::Create(
     const std::string& key_system,
     const GURL& security_origin,
     const CreatePepperCdmCB& create_pepper_cdm_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) {
   std::string plugin_type = GetPepperType(key_system);
   DCHECK(!plugin_type.empty());
@@ skipping 72 matching lines @@
     const std::string& web_session_id,
     scoped_ptr<media::NewSessionCdmPromise> promise) {
   DVLOG(2) << __FUNCTION__;
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
 
   if (!CdmDelegate()) {
     promise->reject(INVALID_STATE_ERROR, 0, "CdmDelegate() does not exist.");
     return;
   }
 
-  CdmDelegate()->LoadSession(web_session_id, promise.Pass());
+  scoped_ptr<SessionLoadedPromise> session_loaded_promise(
+      new SessionLoadedPromise(promise.Pass(),
+                               base::Bind(&PpapiDecryptor::ResumePlayback,
+                                          weak_ptr_factory_.GetWeakPtr())));
+
+  CdmDelegate()->LoadSession(
+      web_session_id,
+      session_loaded_promise.PassAs<media::NewSessionCdmPromise>());
 }
 
 void PpapiDecryptor::UpdateSession(
     const std::string& web_session_id,
     const uint8* response,
     int response_length,
     scoped_ptr<media::SimpleCdmPromise> promise) {
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
 
   if (!CdmDelegate()) {
@@ skipping 273 matching lines @@
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
   pepper_cdm_wrapper_.reset();
 }
 
 ContentDecryptorDelegate* PpapiDecryptor::CdmDelegate() {
   DCHECK(render_loop_proxy_->BelongsToCurrentThread());
   return (pepper_cdm_wrapper_) ? pepper_cdm_wrapper_->GetCdmDelegate() : NULL;
 }
 
 }  // namespace content