media: Refactor PlatformVerificationFlow.

media/cdm/proxy_decryptor.cc

Index: media/cdm/proxy_decryptor.cc
diff --git a/media/cdm/proxy_decryptor.cc b/media/cdm/proxy_decryptor.cc
index d1be9d8b204fe2b99d4dbf3a368cc733ea8af852..82330902fd606cd005378033542859c410ad923c 100644
--- a/media/cdm/proxy_decryptor.cc
+++ b/media/cdm/proxy_decryptor.cc
@@ -29,7 +29,8 @@ 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),
@@ -59,6 +60,9 @@ bool ProxyDecryptor::InitializeCDM(CdmFactory* cdm_factory,
   if (!media_keys_)
     return false;
 
+  key_system_ = key_system;
+  security_origin_ = security_origin;
+
   is_clear_key_ =
       IsClearKey(key_system) || IsExternalClearKey(key_system);
   return true;
@@ -103,10 +107,10 @@ bool ProxyDecryptor::GenerateKeyRequest(const std::string& init_data_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),
@@ -120,12 +124,47 @@ bool ProxyDecryptor::GenerateKeyRequest(const std::string& init_data_type,
           ? MediaKeys::PERSISTENT_LICENSE_SESSION
           : MediaKeys::TEMPORARY_SESSION;
 
-  media_keys_->CreateSessionAndGenerateRequest(
-      session_type, init_data_type, init_data_vector_data,
-      init_data_vector.size(), promise.Pass());
+  // 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.size(),
+      promise.Pass());
+}
+
 void ProxyDecryptor::AddKey(const uint8* key,
                             int key_length,
                             const uint8* init_data,