Rename PermissionBubbleRequest to PermissionRequest

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/metrics/user_metrics_action.h"
 #include "build/build_config.h"
+#include "chrome/browser/permissions/permission_request.h"
 #include "chrome/browser/permissions/permission_uma_util.h"
-#include "chrome/browser/ui/website_settings/permission_bubble_request.h"
 #include "chrome/common/chrome_switches.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/user_metrics.h"
 #include "url/origin.h"
 
 #if !defined(OS_ANDROID)
 #include "chrome/browser/ui/browser_finder.h"
 #endif
 
 namespace {
 
-class CancelledRequest : public PermissionBubbleRequest {
+class CancelledRequest : public PermissionRequest {
  public:
-  explicit CancelledRequest(PermissionBubbleRequest* cancelled)
+  explicit CancelledRequest(PermissionRequest* cancelled)
       : icon_(cancelled->GetIconId()),
         message_fragment_(cancelled->GetMessageTextFragment()),
         origin_(cancelled->GetOrigin()) {}
   ~CancelledRequest() override {}
 
   int GetIconId() const override { return icon_; }
   base::string16 GetMessageTextFragment() const override {
     return message_fragment_;
   }
   GURL GetOrigin() const override { return origin_; }
 
   // These are all no-ops since the placeholder is non-forwarding.
   void PermissionGranted() override {}
   void PermissionDenied() override {}
   void Cancelled() override {}
 
   void RequestFinished() override { delete this; }
 
  private:
   int icon_;
   base::string16 message_fragment_;
   GURL origin_;
 };
 
-bool IsMessageTextEqual(PermissionBubbleRequest* a,
-                        PermissionBubbleRequest* b) {
+bool IsMessageTextEqual(PermissionRequest* a,
+                        PermissionRequest* b) {
   if (a == b)
     return true;
   if (a->GetMessageTextFragment() == b->GetMessageTextFragment() &&
       a->GetOrigin() == b->GetOrigin()) {
     return true;
   }
   return false;
 }
 
 }  // namespace
@@ skipping 19 matching lines @@
       view_(nullptr),
       main_frame_has_fully_loaded_(false),
       auto_response_for_test_(NONE),
       weak_factory_(this) {
 }
 
 PermissionRequestManager::~PermissionRequestManager() {
   if (view_ != NULL)
     view_->SetDelegate(NULL);
 
-  for (PermissionBubbleRequest* request : requests_)
+  for (PermissionRequest* request : requests_)
     request->RequestFinished();
-  for (PermissionBubbleRequest* request : queued_requests_)
+  for (PermissionRequest* request : queued_requests_)
     request->RequestFinished();
-  for (PermissionBubbleRequest* request : queued_frame_requests_)
+  for (PermissionRequest* request : queued_frame_requests_)
     request->RequestFinished();
   for (const auto& entry : duplicate_requests_)
     entry.second->RequestFinished();
 }
 
-void PermissionRequestManager::AddRequest(PermissionBubbleRequest* request) {
+void PermissionRequestManager::AddRequest(PermissionRequest* request) {
+  // TODO(tsergeant): change the UMA to no longer mention bubbles.
   content::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
   // page? We should maybe listen to DidStartNavigationToPendingEntry (and
   // any other renderer-side nav initiations?). Double-check this for
   // correct behavior on interstitials -- we probably want to basically queue
   // any request for which GetVisibleURL != GetLastCommittedURL.
   request_url_ = web_contents()->GetLastCommittedURL();
   bool is_main_frame = url::Origin(request_url_)
                            .IsSameOriginWith(url::Origin(request->GetOrigin()));
 
   // Don't re-add an existing request or one with a duplicate text request.
-  PermissionBubbleRequest* existing_request = GetExistingRequest(request);
+  PermissionRequest* existing_request = GetExistingRequest(request);
   if (existing_request) {
     // |request| is a duplicate. Add it to |duplicate_requests_| unless it's the
     // same object as |existing_request| or an existing duplicate.
     if (request == existing_request)
       return;
     auto range = duplicate_requests_.equal_range(existing_request);
     for (auto it = range.first; it != range.second; ++it) {
       if (request == it->second)
         return;
     }
@@ skipping 19 matching lines @@
     accept_states_.push_back(true);
   } else {
     content::RecordAction(
         base::UserMetricsAction("PermissionBubbleIFrameRequestQueued"));
     queued_frame_requests_.push_back(request);
   }
 
   ScheduleShowBubble();
 }
 
-void PermissionRequestManager::CancelRequest(PermissionBubbleRequest* request) {
+void PermissionRequestManager::CancelRequest(PermissionRequest* request) {
   // First look in the queued requests, where we can simply finish the request
   // and go on.
-  std::vector<PermissionBubbleRequest*>::iterator requests_iter;
+  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();
@@ skipping 22 matching lines @@
 
       if (IsBubbleVisible()) {
         view_->Hide();
         // Will redraw the bubble if it is being shown.
         TriggerShowBubble();
       }
       return;
     }
 
     // Cancel the existing request and replace it with a dummy.
-    PermissionBubbleRequest* cancelled_request =
+    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
   // 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.
-  PermissionBubbleRequest* existing_request = GetExistingRequest(request);
+  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;
     }
   }
 
   NOTREACHED();  // Callers should not cancel requests that are not pending.
@@ skipping 79 matching lines @@
 }
 
 void PermissionRequestManager::ToggleAccept(int request_index, bool new_value) {
   DCHECK(request_index < static_cast<int>(accept_states_.size()));
   accept_states_[request_index] = new_value;
 }
 
 void PermissionRequestManager::Accept() {
   PermissionUmaUtil::PermissionPromptAccepted(requests_, accept_states_);
 
-  std::vector<PermissionBubbleRequest*>::iterator requests_iter;
+  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 (*accepts_iter) {
       PermissionGrantedIncludingDuplicates(*requests_iter);
     } else {
       PermissionDeniedIncludingDuplicates(*requests_iter);
     }
   }
   FinalizeBubble();
 }
 
 void PermissionRequestManager::Deny() {
   PermissionUmaUtil::PermissionPromptDenied(requests_);
 
-  std::vector<PermissionBubbleRequest*>::iterator requests_iter;
+  std::vector<PermissionRequest*>::iterator requests_iter;
   for (requests_iter = requests_.begin();
        requests_iter != requests_.end();
        requests_iter++) {
     PermissionDeniedIncludingDuplicates(*requests_iter);
   }
   FinalizeBubble();
 }
 
 void PermissionRequestManager::Closing() {
-  std::vector<PermissionBubbleRequest*>::iterator requests_iter;
+  std::vector<PermissionRequest*>::iterator requests_iter;
   for (requests_iter = requests_.begin();
        requests_iter != requests_.end();
        requests_iter++) {
     CancelledIncludingDuplicates(*requests_iter);
   }
   FinalizeBubble();
 }
 
 void PermissionRequestManager::ScheduleShowBubble() {
   // ::ScheduleShowBubble() will be called again when the main frame will be
@@ skipping 36 matching lines @@
 
   // If in testing mode, automatically respond to the bubble that was shown.
   if (auto_response_for_test_ != NONE)
     DoAutoResponseForTesting();
 }
 
 void PermissionRequestManager::FinalizeBubble() {
   if (view_)
     view_->Hide();
 
-  std::vector<PermissionBubbleRequest*>::iterator requests_iter;
+  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())
     TriggerShowBubble();
   else
     request_url_ = GURL();
 }
 
 void PermissionRequestManager::CancelPendingQueues() {
-  std::vector<PermissionBubbleRequest*>::iterator requests_iter;
+  std::vector<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();
 }
 
-PermissionBubbleRequest* PermissionRequestManager::GetExistingRequest(
-    PermissionBubbleRequest* request) {
-  for (PermissionBubbleRequest* existing_request : requests_)
+PermissionRequest* PermissionRequestManager::GetExistingRequest(
+    PermissionRequest* request) {
+  for (PermissionRequest* existing_request : requests_)
     if (IsMessageTextEqual(existing_request, request))
       return existing_request;
-  for (PermissionBubbleRequest* existing_request : queued_requests_)
+  for (PermissionRequest* existing_request : queued_requests_)
     if (IsMessageTextEqual(existing_request, request))
       return existing_request;
-  for (PermissionBubbleRequest* existing_request : queued_frame_requests_)
+  for (PermissionRequest* existing_request : queued_frame_requests_)
     if (IsMessageTextEqual(existing_request, request))
       return existing_request;
   return nullptr;
 }
 
 void PermissionRequestManager::PermissionGrantedIncludingDuplicates(
-    PermissionBubbleRequest* request) {
+    PermissionRequest* request) {
   DCHECK_EQ(request, GetExistingRequest(request))
       << "Only requests in [queued_[frame_]]requests_ can have duplicates";
   request->PermissionGranted();
   auto range = duplicate_requests_.equal_range(request);
   for (auto it = range.first; it != range.second; ++it)
     it->second->PermissionGranted();
 }
 void PermissionRequestManager::PermissionDeniedIncludingDuplicates(
-    PermissionBubbleRequest* request) {
+    PermissionRequest* request) {
   DCHECK_EQ(request, GetExistingRequest(request))
       << "Only requests in [queued_[frame_]]requests_ can have duplicates";
   request->PermissionDenied();
   auto range = duplicate_requests_.equal_range(request);
   for (auto it = range.first; it != range.second; ++it)
     it->second->PermissionDenied();
 }
 void PermissionRequestManager::CancelledIncludingDuplicates(
-    PermissionBubbleRequest* request) {
+    PermissionRequest* request) {
   DCHECK_EQ(request, GetExistingRequest(request))
       << "Only requests in [queued_[frame_]]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(
-    PermissionBubbleRequest* request) {
+    PermissionRequest* request) {
   // We can't call GetExistingRequest here, because other entries in requests_,
   // queued_requests_ or queued_frame_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";
   request->RequestFinished();
   // Beyond this point, |request| has probably been deleted.
@@ skipping 24 matching lines @@
     case DENY_ALL:
       Deny();
       break;
     case DISMISS:
       Closing();
       break;
     case NONE:
       NOTREACHED();
   }
 }