media: Refactor PlatformVerificationFlow.

media/cdm/proxy_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 "media/cdm/proxy_decryptor.h"
 
 #include <cstring>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 11 matching lines @@
 
 // Special system code to signal a closed persistent session in a SessionError()
 // call. This is needed because there is no SessionClosed() call in the prefixed
 // EME API.
 const int kSessionClosedSystemCode = 29127;
 
 ProxyDecryptor::ProxyDecryptor(MediaPermission* media_permission,
                                const KeyAddedCB& key_added_cb,
                                const KeyErrorCB& key_error_cb,
                                const KeyMessageCB& key_message_cb)
-    : key_added_cb_(key_added_cb),
+    : media_permission_(media_permission),
+      key_added_cb_(key_added_cb),
       key_error_cb_(key_error_cb),
       key_message_cb_(key_message_cb),
       is_clear_key_(false),
       weak_ptr_factory_(this) {
   DCHECK(media_permission);
   DCHECK(!key_added_cb_.is_null());
   DCHECK(!key_error_cb_.is_null());
   DCHECK(!key_message_cb_.is_null());
 }
 
 ProxyDecryptor::~ProxyDecryptor() {
   // Destroy the decryptor explicitly before destroying the plugin.
   media_keys_.reset();
 }
 
 CdmContext* ProxyDecryptor::GetCdmContext() {
   return media_keys_ ? media_keys_->GetCdmContext() : nullptr;
 }
 
 bool ProxyDecryptor::InitializeCDM(CdmFactory* cdm_factory,
                                    const std::string& key_system,
                                    const GURL& security_origin) {
   DVLOG(1) << "InitializeCDM: key_system = " << key_system;
 
   DCHECK(!media_keys_);
   media_keys_ = CreateMediaKeys(cdm_factory, key_system, security_origin);
   if (!media_keys_)
     return false;
 
+  key_system_ = key_system;
+  security_origin_ = security_origin;
+
   is_clear_key_ =
       IsClearKey(key_system) || IsExternalClearKey(key_system);
   return true;
 }
 
 // Returns true if |data| is prefixed with |header| and has data after the
 // |header|.
 bool HasHeader(const uint8* data, int data_length, const std::string& header) {
   return static_cast<size_t>(data_length) > header.size() &&
          std::equal(data, data + header.size(), header.begin());
@@ skipping 24 matching lines @@
   }
 
   scoped_ptr<NewSessionCdmPromise> promise(
       new CdmCallbackPromise<std::string>(
           base::Bind(&ProxyDecryptor::SetSessionId,
                      weak_ptr_factory_.GetWeakPtr(),
                      session_creation_type),
           base::Bind(&ProxyDecryptor::OnSessionError,
                      weak_ptr_factory_.GetWeakPtr(),
                      std::string())));  // No session id until created.
   uint8* init_data_vector_data =

[ddorwin, 2015/03/12 03:58:12]

Move to 114

[xhwang, 2015/03/12 17:35:27]

Done.

       (init_data_vector.size() > 0) ? &init_data_vector[0] : nullptr;
 
   if (session_creation_type == LoadSession) {
     media_keys_->LoadSession(

[ddorwin, 2015/03/12 03:58:12]

In theory, a user could have allowed then denied and an app is now attempting to
load. Chrome OS would block any requests. Android may not, but we don't support
load there, so this is probably fine (and it's slated for removal).

[xhwang, 2015/03/12 17:35:27]

Acknowledged.

         MediaKeys::PERSISTENT_LICENSE_SESSION,
         std::string(reinterpret_cast<const char*>(init_data_vector_data),
                     init_data_vector.size()),
         promise.Pass());
     return true;
   }
 
   MediaKeys::SessionType session_type =
       session_creation_type == PersistentSession
           ? MediaKeys::PERSISTENT_LICENSE_SESSION
           : MediaKeys::TEMPORARY_SESSION;
 
+  // No permission required when AesDecryptor is used.
+  DCHECK(!key_system_.empty());
+  if (CanUseAesDecryptor(key_system_)) {
+    OnPermissionStatus(session_type, init_data_type, init_data_vector,
+                       promise.Pass(), true /* granted */);
+    return true;
+  }
+
+#if defined(OS_CHROMEOS)
+  media_permission_->RequestPermission(

[ddorwin, 2015/03/12 03:58:12]

External Clear Key will now prompt. I guess that's fine.

[xhwang, 2015/03/12 17:35:27]

Actually External Clear Key browser tests fail now :) Fixed this...

+      MediaPermission::PROTECTED_MEDIA_IDENTIFIER, security_origin_,
+      base::Bind(&ProxyDecryptor::OnPermissionStatus,
+                 weak_ptr_factory_.GetWeakPtr(), session_type, init_data_type,
+                 init_data_vector, base::Passed(&promise)));
+#else
+  // TODO(xhwang): Fix the Android path by requesting permission for key systems
+  // that don't use AesDecryptor.

[ddorwin, 2015/03/12 03:58:12]

Bug? Deadline?

[xhwang, 2015/03/12 17:35:27]

I'll do it right after this CL. Just don't want to make this CL even bigger.
Added deadline.

+  OnPermissionStatus(session_type, init_data_type, init_data_vector,
+                     promise.Pass(), true /* granted */);
+#endif
+
+  return true;
+}
+
+void ProxyDecryptor::OnPermissionStatus(
+    MediaKeys::SessionType session_type,
+    const std::string& init_data_type,
+    const std::vector<uint8>& init_data,
+    scoped_ptr<NewSessionCdmPromise> promise,
+    bool granted) {
+  DVLOG_IF(1, !granted) << "Permission request rejected.";
+
+  const uint8* init_data_vector_data =
+      (init_data.size() > 0) ? &init_data[0] : nullptr;
+
   media_keys_->CreateSessionAndGenerateRequest(
-      session_type, init_data_type, init_data_vector_data,
-      init_data_vector.size(), promise.Pass());
-  return true;
+      session_type, init_data_type, init_data_vector_data, init_data.size(),
+      promise.Pass());
 }
 
 void ProxyDecryptor::AddKey(const uint8* key,
                             int key_length,
                             const uint8* init_data,
                             int init_data_length,
                             const std::string& session_id) {
   DVLOG(1) << "AddKey()";
 
   // In the prefixed API, the session parameter provided to addKey() is
@@ skipping 159 matching lines @@
   bool is_persistent =
       session_type == PersistentSession || session_type == LoadSession;
   active_sessions_.insert(std::make_pair(session_id, is_persistent));
 
   // For LoadSession(), generate the KeyAdded event.
   if (session_type == LoadSession)
     GenerateKeyAdded(session_id);
 }
 
 }  // namespace media