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 =
-      (init_data_vector.size() > 0) ? &init_data_vector[0] : nullptr;
 
   if (session_creation_type == LoadSession) {
+    uint8* init_data_vector_data =
+      (init_data_vector.size() > 0) ? &init_data_vector[0] : nullptr;
     media_keys_->LoadSession(
         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 or when the key system is
+  // external clear key.
+  DCHECK(!key_system_.empty());
+  if (CanUseAesDecryptor(key_system_) || IsExternalClearKey(key_system_)) {

[ddorwin, 2015/03/12 21:38:54]

Do Widevine browser tests fail too (on the linux_chromeos bots)?

[xhwang, 2015/03/13 00:54:42]

No. Only ECK failed.

+    OnPermissionStatus(session_type, init_data_type, init_data_vector,
+                       promise.Pass(), true /* granted */);
+    return true;
+  }
+
+#if defined(OS_CHROMEOS)
+  media_permission_->RequestPermission(
+      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 in M43.
+  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.";

[Darren Krahn, 2015/03/12 22:12:17]

Maybe I'm not following -- is this all we do when the user rejects? It looks
like |granted| is not checked anywhere.

[xhwang, 2015/03/13 00:54:42]

ProxyDecryptor is only used by Prefixed EME, where RequestPermission() is mainly
for triggering the permission UI. Later when we call CheckPermission() (e.g. in
PlatformVerificationFlow), we'll fail there.

In unprefixed EME, we'll also call RequestPermission() [1], and the result is
not ignored [2].

[1]
https://code.google.com/p/chromium/codesearch#chromium/src/media/blink/webenc...

[2]
https://code.google.com/p/chromium/codesearch#chromium/src/media/blink/webenc...

You can think it this way:
- Unprefixed EME needs to call RequestPermission early and show the UI.
- Since we don't want to show the UI twice to the user, we should NOT trigger UI
in PlatformVerificationFlow, hence CheckPermission() instead of
RequestPermission there.
- But we still want to show UI to user at least once for prefixed EME, so call
RequestPermission() in ProxyDecryptor.

[Darren Krahn, 2015/03/13 22:47:11]

Understood. Can you please put a comment to clarify this in the code? Likely
others will have a similar question.

[xhwang, 2015/03/13 23:52:50]

Done.

+
+  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