media: Support simultaneous permission requests from multiple WebContents in ProtectedMediaIdentifi…

chrome/browser/media/protected_media_identifier_permission_context.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 "chrome/browser/media/protected_media_identifier_permission_context.h"
 
 #include "base/prefs/pref_service.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "components/content_settings/core/common/permission_request_id.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 
 #if defined(OS_CHROMEOS)
+#include <utility>
+
 #include "chrome/browser/chromeos/attestation/platform_verification_dialog.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "ui/views/widget/widget.h"
 
 using chromeos::attestation::PlatformVerificationDialog;
 using chromeos::attestation::PlatformVerificationFlow;
 #endif
 
-#if defined(OS_CHROMEOS)
-namespace {
-PermissionRequestID GetInvalidPendingId() {
-  return PermissionRequestID(-1, -1, -1, GURL());
-}
-}
-#endif
-
 ProtectedMediaIdentifierPermissionContext::
     ProtectedMediaIdentifierPermissionContext(Profile* profile)
     : PermissionContextBase(profile,
                             CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER)
 #if defined(OS_CHROMEOS)
       ,
-      pending_id_(GetInvalidPendingId()),
-      widget_(nullptr),
       weak_factory_(this)
 #endif
 {
 }
 
 ProtectedMediaIdentifierPermissionContext::
     ~ProtectedMediaIdentifierPermissionContext() {
 }
 
 void ProtectedMediaIdentifierPermissionContext::RequestPermission(
@@ skipping 28 matching lines @@
                           false /* persist */, false /* granted */);
       return;
     case CONTENT_SETTING_ALLOW:
       NotifyPermissionSet(id, requesting_origin, embedding_origin, callback,
                           false /* persist */, true /* granted */);
       return;
     default:
       break;
   }
 
-  // We only support one prompt and one pending permission request.
+  // Since the dialog is modal, we only support one prompt per |web_contents|.
   // Reject the new one if there is already one pending. See
   // http://crbug.com/447005
-  if (!pending_id_.Equals(GetInvalidPendingId())) {
+  if (pending_requests_.count(web_contents)) {
     callback.Run(false);
     return;
   }
 
-  pending_id_ = id;
-  widget_ = PlatformVerificationDialog::ShowDialog(
+  views::Widget* widget = PlatformVerificationDialog::ShowDialog(
       web_contents, requesting_origin,
       base::Bind(&ProtectedMediaIdentifierPermissionContext::
                      OnPlatformVerificationResult,
-                 weak_factory_.GetWeakPtr(), id, requesting_origin,
-                 embedding_origin, callback));
+                 weak_factory_.GetWeakPtr(), web_contents, id,
+                 requesting_origin, embedding_origin, callback));
+  pending_requests_.insert(
+      std::make_pair(web_contents, std::make_pair(widget, id)));
 #else
   PermissionContextBase::RequestPermission(web_contents, id, requesting_origin,
                                            user_gesture, callback);
 #endif
 }
 
 ContentSetting ProtectedMediaIdentifierPermissionContext::GetPermissionStatus(
       const GURL& requesting_origin,
       const GURL& embedding_origin) const {
   if (!IsProtectedMediaIdentifierEnabled())
     return CONTENT_SETTING_BLOCK;
 
   return PermissionContextBase::GetPermissionStatus(requesting_origin,
                                                     embedding_origin);
 }
 
 void ProtectedMediaIdentifierPermissionContext::CancelPermissionRequest(
     content::WebContents* web_contents,
     const PermissionRequestID& id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
 #if defined(OS_CHROMEOS)
-  if (!widget_ || !pending_id_.Equals(id))
+  PendingRequestMap::iterator request = pending_requests_.find(web_contents);
+  if (request == pending_requests_.end() || !request->second.second.Equals(id))
     return;
 
   // Close the |widget_|. OnPlatformVerificationResult() will be fired
-  // during this process, but since |pending_id_| is cleared, the callback will
-  // be dropped.
-  pending_id_ = GetInvalidPendingId();
-  widget_->Close();
-  return;
+  // during this process, but since |web_contents| is removed from
+  // |pending_requests_|, the callback will simply be dropped.
+  views::Widget* widget = request->second.first;
+  pending_requests_.erase(request);
+  widget->Close();
 #else
   PermissionContextBase::CancelPermissionRequest(web_contents, id);
 #endif
 }
 
 void ProtectedMediaIdentifierPermissionContext::UpdateTabContext(
     const PermissionRequestID& id,
     const GURL& requesting_frame,
     bool allowed) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
@@ skipping 29 matching lines @@
             profile()->GetPrefs()->GetBoolean(prefs::kEnableDRM);
 #endif
 
   DVLOG_IF(1, !enabled)
       << "Protected media identifier disabled by the user or by device policy.";
   return enabled;
 }
 
 #if defined(OS_CHROMEOS)
 void ProtectedMediaIdentifierPermissionContext::OnPlatformVerificationResult(
+    content::WebContents* web_contents,
     const PermissionRequestID& id,
     const GURL& requesting_origin,
     const GURL& embedding_origin,
     const BrowserPermissionCallback& callback,
     chromeos::attestation::PlatformVerificationFlow::ConsentResponse response) {
-  DCHECK(widget_);
-  widget_ = nullptr;
-
-  // The request may have been canceled. Drop the callback here.
-  if (!pending_id_.Equals(id))
+  // The request may have been canceled. Drop the callback in that case.
+  PendingRequestMap::iterator request = pending_requests_.find(web_contents);
+  if (request == pending_requests_.end())
     return;
 
-  pending_id_ = GetInvalidPendingId();
+  DCHECK(request->second.second.Equals(id));
+  pending_requests_.erase(request);
 
   if (response == PlatformVerificationFlow::CONSENT_RESPONSE_NONE) {
     // Deny request and do not save to content settings.
     NotifyPermissionSet(id, requesting_origin, embedding_origin, callback,
                         false,   // Do not save to content settings.
                         false);  // Do not allow the permission.
     return;
   }
 
   NotifyPermissionSet(
       id, requesting_origin, embedding_origin, callback,
       true,  // Save to content settings.
       response == PlatformVerificationFlow::CONSENT_RESPONSE_ALLOW);
 }
 #endif