Only show grouped permission bubbles for mic/camera permissions

chrome/browser/permissions/permission_request_manager.cc

 // Copyright 2014 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_request_manager.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/feature_list.h"
@@ skipping 42 matching lines @@
                         PermissionRequest* b) {
   if (a == b)
     return true;
   if (a->GetMessageTextFragment() == b->GetMessageTextFragment() &&
       a->GetOrigin() == b->GetOrigin()) {
     return true;
   }
   return false;
 }
 
+// We only group together media requests. We don't display grouped requests for
+// any other permissions at present.
+bool ShouldGroupRequests(PermissionRequest* a, PermissionRequest* b) {
+  if (a->GetOrigin() != b->GetOrigin())
+    return false;
+
+  if (a->GetPermissionRequestType() ==
+      PermissionRequestType::PERMISSION_MEDIASTREAM_MIC) {
+    return b->GetPermissionRequestType() ==
+           PermissionRequestType::PERMISSION_MEDIASTREAM_CAMERA;
+  }
+
+  if (a->GetPermissionRequestType() ==
+      PermissionRequestType::PERMISSION_MEDIASTREAM_CAMERA) {
+    return b->GetPermissionRequestType() ==
+           PermissionRequestType::PERMISSION_MEDIASTREAM_MIC;
+  }
+
+  return false;
+}
+
 }  // namespace
 
 // PermissionRequestManager::Observer ------------------------------------------
 
 PermissionRequestManager::Observer::~Observer() {
 }
 
 void PermissionRequestManager::Observer::OnBubbleAdded() {
 }
 
@@ skipping 17 matching lines @@
 }
 
 PermissionRequestManager::~PermissionRequestManager() {
   if (view_ != NULL)
     view_->SetDelegate(NULL);
 
   for (PermissionRequest* request : requests_)
     request->RequestFinished();
   for (PermissionRequest* request : queued_requests_)
     request->RequestFinished();
-  for (PermissionRequest* request : queued_frame_requests_)
-    request->RequestFinished();
   for (const auto& entry : duplicate_requests_)
     entry.second->RequestFinished();
 }
 
 void PermissionRequestManager::AddRequest(PermissionRequest* request) {
   // TODO(tsergeant): change the UMA to no longer mention bubbles.
   base::RecordAction(base::UserMetricsAction("PermissionBubbleRequest"));
 
   // TODO(gbillock): is there a race between an early request on a
   // newly-navigated page and the to-be-cleaned-up requests on the previous
@@ skipping 19 matching lines @@
     }
     duplicate_requests_.insert(std::make_pair(existing_request, request));
     return;
   }
 
   if (is_main_frame) {
     if (IsBubbleVisible()) {
       base::RecordAction(
           base::UserMetricsAction("PermissionBubbleRequestQueued"));
     }
-    queued_requests_.push_back(request);
   } else {
     base::RecordAction(
         base::UserMetricsAction("PermissionBubbleIFrameRequestQueued"));
-    queued_frame_requests_.push_back(request);
   }
+  queued_requests_.push_back(request);
 
   if (!IsBubbleVisible())
     ScheduleShowBubble();
 }
 
 void PermissionRequestManager::CancelRequest(PermissionRequest* request) {
   // First look in the queued requests, where we can simply finish the request
   // and go on.
-  std::vector<PermissionRequest*>::iterator requests_iter;
-  for (requests_iter = queued_requests_.begin();
-       requests_iter != queued_requests_.end();
-       requests_iter++) {
-    if (*requests_iter == request) {
-      RequestFinishedIncludingDuplicates(*requests_iter);
-      queued_requests_.erase(requests_iter);
-      return;
-    }
-  }
-  for (requests_iter = queued_frame_requests_.begin();
-       requests_iter != queued_frame_requests_.end(); requests_iter++) {
-    if (*requests_iter == request) {
-      RequestFinishedIncludingDuplicates(*requests_iter);
-      queued_frame_requests_.erase(requests_iter);
+  std::deque<PermissionRequest*>::iterator queued_requests_iter;
+  for (queued_requests_iter = queued_requests_.begin();
+       queued_requests_iter != queued_requests_.end(); queued_requests_iter++) {
+    if (*queued_requests_iter == request) {
+      RequestFinishedIncludingDuplicates(*queued_requests_iter);
+      queued_requests_.erase(queued_requests_iter);
       return;
     }
   }
 
+  std::vector<PermissionRequest*>::iterator requests_iter;
   std::vector<bool>::iterator accepts_iter = accept_states_.begin();
   for (requests_iter = requests_.begin(), accepts_iter = accept_states_.begin();
        requests_iter != requests_.end();
        requests_iter++, accepts_iter++) {
     if (*requests_iter != request)
       continue;
 
     // We can simply erase the current entry in the request table if we aren't
     // showing the dialog, or if we are showing it and it can accept the update.
     bool can_erase = !view_ || view_->CanAcceptRequestUpdate();
@@ skipping 11 matching lines @@
     }
 
     // Cancel the existing request and replace it with a dummy.
     PermissionRequest* cancelled_request =
         new CancelledRequest(*requests_iter);
     RequestFinishedIncludingDuplicates(*requests_iter);
     *requests_iter = cancelled_request;
     return;
   }
 
-  // Since |request| wasn't found in queued_requests_, queued_frame_requests_ or
+  // Since |request| wasn't found in queued_requests_ or
   // requests_ it must have been marked as a duplicate. We can't search
   // duplicate_requests_ by value, so instead use GetExistingRequest to find the
   // key (request it was duped against), and iterate through duplicates of that.
   PermissionRequest* existing_request = GetExistingRequest(request);
   auto range = duplicate_requests_.equal_range(existing_request);
   for (auto it = range.first; it != range.second; ++it) {
     if (request == it->second) {
       it->second->RequestFinished();
       duplicate_requests_.erase(it);
       return;
@@ skipping 166 matching lines @@
                      weak_factory_.GetWeakPtr()));
 }
 
 void PermissionRequestManager::DequeueRequestsAndShowBubble() {
   if (!view_)
     return;
   if (!requests_.empty())
     return;
   if (!main_frame_has_fully_loaded_)
     return;
-  if (queued_requests_.empty() && queued_frame_requests_.empty())
+  if (queued_requests_.empty())
     return;
 
-  if (queued_requests_.size())
-    requests_.swap(queued_requests_);
-  else
-    requests_.swap(queued_frame_requests_);
+  requests_.push_back(queued_requests_.front());
+  queued_requests_.pop_front();
+
+  if (!queued_requests_.empty() &&
+      ShouldGroupRequests(requests_.front(), queued_requests_.front())) {
+    requests_.push_back(queued_requests_.front());
+    queued_requests_.pop_front();
+  }
 
   // Sets the default value for each request to be 'accept'.
   accept_states_.resize(requests_.size(), true);
 
   ShowBubble();
 }
 
 void PermissionRequestManager::ShowBubble() {
   DCHECK(view_);
   DCHECK(!requests_.empty());
@@ skipping 13 matching lines @@
     view_->Hide();
 
   std::vector<PermissionRequest*>::iterator requests_iter;
   for (requests_iter = requests_.begin();
        requests_iter != requests_.end();
        requests_iter++) {
     RequestFinishedIncludingDuplicates(*requests_iter);
   }
   requests_.clear();
   accept_states_.clear();
-  if (queued_requests_.size() || queued_frame_requests_.size())
+  if (queued_requests_.size())
     DequeueRequestsAndShowBubble();
 }
 
 void PermissionRequestManager::CancelPendingQueues() {
-  std::vector<PermissionRequest*>::iterator requests_iter;
+  std::deque<PermissionRequest*>::iterator requests_iter;
   for (requests_iter = queued_requests_.begin();
        requests_iter != queued_requests_.end();
        requests_iter++) {
     RequestFinishedIncludingDuplicates(*requests_iter);
   }
-  for (requests_iter = queued_frame_requests_.begin();
-       requests_iter != queued_frame_requests_.end();
-       requests_iter++) {
-    RequestFinishedIncludingDuplicates(*requests_iter);
-  }
   queued_requests_.clear();
-  queued_frame_requests_.clear();
 }
 
 PermissionRequest* PermissionRequestManager::GetExistingRequest(
     PermissionRequest* request) {
   for (PermissionRequest* existing_request : requests_)
     if (IsMessageTextEqual(existing_request, request))
       return existing_request;
   for (PermissionRequest* existing_request : queued_requests_)
     if (IsMessageTextEqual(existing_request, request))
       return existing_request;
-  for (PermissionRequest* existing_request : queued_frame_requests_)
-    if (IsMessageTextEqual(existing_request, request))
-      return existing_request;
   return nullptr;
 }
 
 void PermissionRequestManager::PermissionGrantedIncludingDuplicates(
     PermissionRequest* request) {
   DCHECK_EQ(request, GetExistingRequest(request))
       << "Only requests in [queued_[frame_]]requests_ can have duplicates";
   request->set_persist(persist_);
   request->PermissionGranted();
   auto range = duplicate_requests_.equal_range(request);
   for (auto it = range.first; it != range.second; ++it) {
     it->second->set_persist(persist_);
     it->second->PermissionGranted();
   }
 }
 void PermissionRequestManager::PermissionDeniedIncludingDuplicates(
     PermissionRequest* request) {
   DCHECK_EQ(request, GetExistingRequest(request))
-      << "Only requests in [queued_[frame_]]requests_ can have duplicates";
+      << "Only requests in [queued_]requests_ can have duplicates";
   request->set_persist(persist_);
   request->PermissionDenied();
   auto range = duplicate_requests_.equal_range(request);
   for (auto it = range.first; it != range.second; ++it) {
     it->second->set_persist(persist_);
     it->second->PermissionDenied();
   }
 }
 void PermissionRequestManager::CancelledIncludingDuplicates(
     PermissionRequest* request) {
   DCHECK_EQ(request, GetExistingRequest(request))
-      << "Only requests in [queued_[frame_]]requests_ can have duplicates";
+      << "Only requests in [queued_]requests_ can have duplicates";
   request->Cancelled();
   auto range = duplicate_requests_.equal_range(request);
   for (auto it = range.first; it != range.second; ++it)
     it->second->Cancelled();
 }
 void PermissionRequestManager::RequestFinishedIncludingDuplicates(
     PermissionRequest* request) {
   // We can't call GetExistingRequest here, because other entries in requests_,
-  // queued_requests_ or queued_frame_requests_ might already have been deleted.
+  // queued_requests_ might already have been deleted.
   DCHECK_EQ(1, std::count(requests_.begin(), requests_.end(), request) +
-               std::count(queued_requests_.begin(), queued_requests_.end(),
-                          request) +
-               std::count(queued_frame_requests_.begin(),
-                          queued_frame_requests_.end(), request))
-      << "Only requests in [queued_[frame_]]requests_ can have duplicates";
+                   std::count(queued_requests_.begin(), queued_requests_.end(),
+                              request))
+      << "Only requests in [queued_]requests_ can have duplicates";
   request->RequestFinished();
   // Beyond this point, |request| has probably been deleted.
   auto range = duplicate_requests_.equal_range(request);
   for (auto it = range.first; it != range.second; ++it)
     it->second->RequestFinished();
   // Additionally, we can now remove the duplicates.
   duplicate_requests_.erase(request);
 }
 
 void PermissionRequestManager::AddObserver(Observer* observer) {
@@ skipping 24 matching lines @@
         Accept();
       }
       break;
     case DISMISS:
       Closing();
       break;
     case NONE:
       NOTREACHED();
   }
 }