Dismiss EME infobar when WebMediaPlayer is destroyed.

content/renderer/media/android/proxy_media_keys.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/android/proxy_media_keys.h"
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 14 matching lines @@
       media_keys_id_(media_keys_id),
       session_created_cb_(session_created_cb),
       session_message_cb_(session_message_cb),
       session_ready_cb_(session_ready_cb),
       session_closed_cb_(session_closed_cb),
       session_error_cb_(session_error_cb) {
   DCHECK(manager_);
 }
 
 ProxyMediaKeys::~ProxyMediaKeys() {
+  for (base::hash_set<uint32>::iterator i = requested_session_id_.begin();
+       i != requested_session_id_.end(); ++i) {
+    manager_->CancelSession(media_keys_id_, *i);
+  }
 }
 
 void ProxyMediaKeys::InitializeCDM(const std::string& key_system,
                                    const GURL& frame_url) {
 #if defined(ENABLE_PEPPER_CDMS)
   NOTIMPLEMENTED();
 #elif defined(OS_ANDROID)
   std::vector<uint8> uuid = GetUUID(key_system);
   DCHECK(!uuid.empty());
   manager_->InitializeCDM(media_keys_id_, this, uuid, frame_url);
 #endif
 }
 
 bool ProxyMediaKeys::CreateSession(uint32 session_id,
                                    const std::string& type,
                                    const uint8* init_data,
                                    int init_data_length) {
+  requested_session_id_.insert(session_id);
   manager_->CreateSession(
       media_keys_id_,
       session_id,
       type,
       std::vector<uint8>(init_data, init_data + init_data_length));
   return true;
 }
 
 void ProxyMediaKeys::UpdateSession(uint32 session_id,
                                    const uint8* response,
                                    int response_length) {
   manager_->UpdateSession(
       media_keys_id_,
       session_id,
       std::vector<uint8>(response, response + response_length));
 }
 
 void ProxyMediaKeys::ReleaseSession(uint32 session_id) {
+  requested_session_id_.erase(session_id);

[ddorwin, 2013/12/20 23:59:52]

You probably don't need this here. See last comment below.

[Kibeom Kim (inactive), 2013/12/30 12:33:05]

Done.

   manager_->ReleaseSession(media_keys_id_, session_id);
 }
 
 void ProxyMediaKeys::OnSessionCreated(uint32 session_id,
                                       const std::string& web_session_id) {
   session_created_cb_.Run(session_id, web_session_id);
 }
 
 void ProxyMediaKeys::OnSessionMessage(uint32 session_id,
                                       const std::vector<uint8>& message,
                                       const std::string& destination_url) {
   session_message_cb_.Run(session_id, message, destination_url);
 }
 
 void ProxyMediaKeys::OnSessionReady(uint32 session_id) {
   session_ready_cb_.Run(session_id);
 }
 
 void ProxyMediaKeys::OnSessionClosed(uint32 session_id) {
+  requested_session_id_.erase(session_id);

[ddorwin, 2013/12/20 23:59:52]

I can't find documentation, but I assume this is a nop if session_id is not
found. Is that right?

Better yet, we should never need to erase here (or line 75) because these should
not be called until the session has been created. You can just convert these to
a DCHECK(find() == end()).

[Kibeom Kim (inactive), 2013/12/30 12:33:05]

(I just assumed the spec is equal to std::set<>::erase();. On Android, I think
the actual implementation is
third_party/android_tools/ndk/sources/cxx-stl/stlport/stlport/stl/_hashtable.c ,
but haven't verified it since now we don't need this line anymore)

   session_closed_cb_.Run(session_id);
 }
 
+void ProxyMediaKeys::OnSessionApproved(uint32 session_id, bool success) {

[ddorwin, 2013/12/20 23:59:52]

Can we just use OnSessionCreated for success and have a OnSessionCreateDenied or
whatever for failure?
 * One or the other will always be called, which mans we can do all erasing in
those two.
 * For implementations that don't involve approval, they don't need to fire this
event. (However, they'd still need to do something to erase the session_id. That
might be a general problem we need to solve. Maybe this should be
OnSessionCreationFailed and called in all those cases. Actually, we call
OnSessionError in one of those cases - maybe we can use that in the not-allowed
case too. xhwang, WDYT?)
 * The naming works better (currently success=false turns "Approved" into not
approved).

The Release and Closed methods are somewhat arbitrary for erasing anyway.

[xhwang, 2013/12/21 00:40:48]

Can we have a CancelAllPendingSessionCreations(media_keys_id) function, which
cancels all pending session creations? Then we don't need requested_session_id_
at all, nor OnSessionApproved.

At the browser side, we can either keep track of pending calls of
RequestProtectedMediaIdentifierPermission, or change
context->CancelProtectedMediaIdentifierPermissionRequest() to
context->CancelAllProtectedMediaIdentifierPermissionRequests().

WDYT?

[ddorwin, 2013/12/21 00:44:56]

Good point. This class is always tied to media_keys_id_, so all we need is to
tell the browser that media_keys_id_ is being destroyed and it should be able to
cancel all requests related to it.

[Kibeom Kim (inactive), 2013/12/21 01:50:43]

So, looks like it's just a matter of which class we want to manage pending
media_keys_id & sessions mapping, and options are:

1. ProxyMediaKeys (current)
2. BrowserMediaPlayerManager (can have CancelAllPendingSessionCreations ipc
message instead of cancelling individually)
3. BrowserContext (if we also want to have
BrowserContext::CancelAllProtectedMediaIdentifierPermissionRequests() method.)
4. ProxyDecryptor

3. is my least favorite option becase I'd prefer to keep BrowserContext simpler
and we have other good options. 2. sounds more attractive than 1. , but, how
about 4.? although we'll need to send the canceling ipc message for individual
session, I don't think there are that many sessions (is this correct??), and
ProxyDecryptor already manages a session map "SessionIdMap sessions_;" so I
think that's less confusing and more consistent option. WDYT?

+  requested_session_id_.erase(session_id);
+}
+
 void ProxyMediaKeys::OnSessionError(uint32 session_id,
                                     media::MediaKeys::KeyError error_code,
                                     int system_code) {
   session_error_cb_.Run(session_id, error_code, system_code);
 }
 
 }  // namespace content