Implement a modal permission dialog on Android gated by a feature.

chrome/browser/permissions/permission_queue_controller.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/permissions/permission_queue_controller.h"
 
+#include "base/feature_list.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/infobars/infobar_service.h"
+#include "chrome/browser/permissions/permission_dialog_delegate.h"
 #include "chrome/browser/permissions/permission_infobar_delegate.h"
 #include "chrome/browser/permissions/permission_request.h"
 #include "chrome/browser/permissions/permission_request_id.h"
 #include "chrome/browser/permissions/permission_uma_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/tab_util.h"
+#include "chrome/common/chrome_features.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/common/content_settings.h"
 #include "components/infobars/core/infobar.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/url_constants.h"
 
 namespace {
 
+content::WebContents* GetWebContents(const PermissionRequestID& id) {
+  return tab_util::GetWebContentsByFrameID(
+      id.render_process_id(), id.render_frame_id());
+}
+
+
 InfoBarService* GetInfoBarService(const PermissionRequestID& id) {
-  content::WebContents* web_contents = tab_util::GetWebContentsByFrameID(
-      id.render_process_id(), id.render_frame_id());
-  return web_contents ? InfoBarService::FromWebContents(web_contents) : NULL;
+  content::WebContents* web_contents = GetWebContents(id);
+  return web_contents ? InfoBarService::FromWebContents(web_contents) : nullptr;
 }
 
 bool ArePermissionRequestsForSameTab(
     const PermissionRequestID& request,
     const PermissionRequestID& other_request) {
   content::WebContents* web_contents = tab_util::GetWebContentsByFrameID(
       request.render_process_id(), request.render_frame_id());
   content::WebContents* other_web_contents = tab_util::GetWebContentsByFrameID(
       other_request.render_process_id(), other_request.render_frame_id());
 
@@ skipping 45 matching lines @@
     bool user_gesture,
     Profile* profile,
     const PermissionDecidedCallback& callback)
     : type_(type),
       id_(id),
       requesting_frame_(requesting_frame),
       embedder_(embedder),
       user_gesture_(user_gesture),
       profile_(profile),
       callback_(callback),
-      infobar_(NULL) {}
+      infobar_(nullptr) {}
 
 PermissionQueueController::PendingInfobarRequest::~PendingInfobarRequest() {
 }
 
 bool PermissionQueueController::PendingInfobarRequest::IsForPair(
     const GURL& requesting_frame,
     const GURL& embedder) const {
   return (requesting_frame_ == requesting_frame) && (embedder_ == embedder);
 }
 
 void PermissionQueueController::PendingInfobarRequest::RunCallback(
     ContentSetting content_setting) {
   callback_.Run(content_setting);
 }
 
 void PermissionQueueController::PendingInfobarRequest::CreateInfoBar(
     PermissionQueueController* controller) {
   // Controller can be Unretained because the lifetime of the infobar
   // is tied to that of the queue controller. Before QueueController
   // is destroyed, all requests will be cancelled and so all delegates
   // will be destroyed.
   PermissionInfoBarDelegate::PermissionSetCallback callback = base::Bind(
       &PermissionQueueController::OnPermissionSet, base::Unretained(controller),
       id_, requesting_frame_, embedder_, user_gesture_);
 
-  infobar_ = PermissionInfoBarDelegate::Create(type_, GetInfoBarService(id_),
-                                               requesting_frame_, user_gesture_,
-                                               profile_, callback);
+  if (base::FeatureList::IsEnabled(features::kModalPermissionPrompts)) {
+    // Only one modal can be shown at a time. This method calls through to Java,
+    // which owns and manages the queue of modal prompts; the bookkeeping in
+    // this class will work as expected:
+    //   i. no pending request will ever have an infobar created for it.
+    //  ii. OnPermissionSet is still called when the user makes a decision.
+    PermissionDialogDelegate::Create(type_, GetWebContents(id_),
+                                     requesting_frame_, user_gesture_, profile_,
+                                     callback);
+  } else {
+    infobar_ = PermissionInfoBarDelegate::Create(
+        type_, GetInfoBarService(id_), requesting_frame_, user_gesture_,
+        profile_, callback);
+  }
 }
 
 PermissionQueueController::PermissionQueueController(
     Profile* profile,
     content::PermissionType permission_type,
     ContentSettingsType content_settings_type)
     : profile_(profile),
       permission_type_(permission_type),
       content_settings_type_(content_settings_type),
       in_shutdown_(false) {}
@@ skipping 78 matching lines @@
   // Cancel this request first, then notify listeners.  TODO(pkasting): Why
   // is this order important?
   PendingInfobarRequests requests_to_notify;
   PendingInfobarRequests infobars_to_remove;
   std::vector<PendingInfobarRequests::iterator> pending_requests_to_remove;
   for (PendingInfobarRequests::iterator i = pending_infobar_requests_.begin();
        i != pending_infobar_requests_.end(); ++i) {
     if (!i->IsForPair(requesting_frame, embedder))
       continue;
     requests_to_notify.push_back(*i);
-    if (!i->has_infobar()) {
-      // We haven't created an infobar yet, just record the pending request
-      // index and remove it later.
+    if (!i->has_infobar() ||
+        base::FeatureList::IsEnabled(features::kModalPermissionPrompts)) {
+      // We haven't created an infobar yet, or no infobars are being created.
+      // Record the pending request index and remove it later.
       pending_requests_to_remove.push_back(i);
       continue;
     }
     if (id == i->id()) {
       // The infobar that called us is i->infobar(), and its delegate is
       // currently in either Accept() or Cancel(). This means that
       // RemoveInfoBar() will be called later on, and that will trigger a
       // notification we're observing.
       continue;
     }
@@ skipping 16 matching lines @@
   ContentSetting content_setting = CONTENT_SETTING_DEFAULT;
   if (decision == GRANTED)
     content_setting = CONTENT_SETTING_ALLOW;
   else if (decision == DENIED)
     content_setting = CONTENT_SETTING_BLOCK;
   else
     DCHECK_EQ(DISMISSED, decision);
 
   // Send out the permission notifications.
   for (PendingInfobarRequests::iterator i = requests_to_notify.begin();
-       i != requests_to_notify.end(); ++i)
+       i != requests_to_notify.end(); ++i) {
     i->RunCallback(content_setting);
+  }
 
   // Remove the pending requests in reverse order.
   for (int i = pending_requests_to_remove.size() - 1; i >= 0; --i)
     pending_infobar_requests_.erase(pending_requests_to_remove[i]);
 }
 
 void PermissionQueueController::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
@@ skipping 46 matching lines @@
   // infobars.
   InfoBarService* infobar_service = GetInfoBarService(id);
   if (!infobar_service || in_shutdown_) {
     ClearPendingInfobarRequestsForTab(id);
     return;
   }
 
   for (PendingInfobarRequests::iterator i = pending_infobar_requests_.begin();
        i != pending_infobar_requests_.end(); ++i) {
     if (ArePermissionRequestsForSameTab(i->id(), id) && !i->has_infobar()) {
-      RegisterForInfoBarNotifications(infobar_service);
+      // When using modal permission prompts, Java controls the display queue,
+      // so infobar notifications are not relevant.
+      if (!base::FeatureList::IsEnabled(features::kModalPermissionPrompts))
+        RegisterForInfoBarNotifications(infobar_service);
+
       i->CreateInfoBar(this);
       return;
     }
   }
 
   UnregisterForInfoBarNotifications(infobar_service);
 }
 
 void PermissionQueueController::ClearPendingInfobarRequestsForTab(
     const PermissionRequestID& id) {
@@ skipping 43 matching lines @@
   }
 
   ContentSetting content_setting =
       (decision == GRANTED) ? CONTENT_SETTING_ALLOW : CONTENT_SETTING_BLOCK;
 
   HostContentSettingsMapFactory::GetForProfile(profile_)
       ->SetContentSettingDefaultScope(
           requesting_frame.GetOrigin(), embedder.GetOrigin(),
           content_settings_type_, std::string(), content_setting);
 }