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 "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 "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 11 matching lines @@
                         bool user_gesture,
                         Profile* profile,
                         const PermissionDecidedCallback& callback);
   ~PendingInfobarRequest();
 
   bool IsForPair(const GURL& requesting_frame,
                  const GURL& embedder) const;
 
   const PermissionRequestID& id() const { return id_; }
   const GURL& requesting_frame() const { return requesting_frame_; }
+  bool has_gesture() const { return user_gesture_; }
   bool has_infobar() const { return !!infobar_; }
   infobars::InfoBar* infobar() { return infobar_; }
 
   void RunCallback(ContentSetting content_setting);
   void CreateInfoBar(PermissionQueueController* controller);
 
  private:
   content::PermissionType type_;
   PermissionRequestID id_;
   GURL requesting_frame_;
@@ skipping 14 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 (PermissionDialogDelegate::PromptUser(user_gesture_)) {

[lshang, 2016/11/01 03:47:44]

I'd rename this method as ShouldPromptUser(), since it's checking whether
eligible to show the prompt and returns a bool. The current name is like action
taken.

[dominickn, 2016/11/01 04:44:00]

Done.

+    // We should show a dialog prompt instead of an infobar. Since only one
+    // dialog can be shown at a time, the Java-side owns and manages the queue
+    // of 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() ||
+        PermissionDialogDelegate::PromptUser(i->has_gesture())) {

[raymes, 2016/11/01 02:56:46]

Is this check strictly necessary? Won't has_infobar be false for the request if
we created a modal for it?

[dominickn, 2016/11/01 03:30:59]

Good point. Removed.

+      // 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 18 matching lines @@
       return;
     }
   }
 }
 
 bool PermissionQueueController::AlreadyShowingInfoBarForTab(
     const PermissionRequestID& id) const {
   for (PendingInfobarRequests::const_iterator i(
            pending_infobar_requests_.begin());
        i != pending_infobar_requests_.end(); ++i) {
     if (ArePermissionRequestsForSameTab(i->id(), id) && i->has_infobar())

[lshang, 2016/11/01 03:47:44]

Should also check if already showing modal prompt here? For example, if there is
already a notification modal prompt showing here, and another notification
request comes, we shouldn't show the same requests twice.

[dominickn, 2016/11/01 04:44:00]

Hmm, that logic doesn't work, because the request for a modal prompt is already
added to the queue of things that we're checking in this method (which is why I
didn't do it originally). But I think you're right in that there's an edge case
here. Instead, I've added a has_dialog() field. That should do the trick,
thanks.

       return true;
   }
   return false;
 }
 
 void PermissionQueueController::ShowQueuedInfoBarForTab(
     const PermissionRequestID& id) {
   DCHECK(!AlreadyShowingInfoBarForTab(id));
 
   // We can get here for example during tab shutdown, when the InfoBarService is
   // removing all existing infobars, thus calling back to Observe(). In this
   // case the service still exists, and is supplied as the source of the
   // notification we observed, but is no longer accessible from its WebContents.
   // In this case we should just go ahead and cancel further infobars for this
   // tab instead of trying to access the service.
   //
   // Similarly, if we're being destroyed, we should also avoid showing further
   // 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 (!PermissionDialogDelegate::PromptUser(i->has_gesture()))
+        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);
 }