Rename PermissionBubbleManager to PermissionRequestManager

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/ui/website_settings/permission_bubble_manager.h"
+#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_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"
@@ skipping 40 matching lines @@
     return true;
   if (a->GetMessageTextFragment() == b->GetMessageTextFragment() &&
       a->GetOrigin() == b->GetOrigin()) {
     return true;
   }
   return false;
 }
 
 }  // namespace
 
-// PermissionBubbleManager::Observer -------------------------------------------
+// PermissionRequestManager::Observer ------------------------------------------
 
-PermissionBubbleManager::Observer::~Observer() {
+PermissionRequestManager::Observer::~Observer() {
 }
 
-void PermissionBubbleManager::Observer::OnBubbleAdded() {
+void PermissionRequestManager::Observer::OnBubbleAdded() {
 }
 
-// PermissionBubbleManager -----------------------------------------------------
+// PermissionRequestManager ----------------------------------------------------
 
-DEFINE_WEB_CONTENTS_USER_DATA_KEY(PermissionBubbleManager);
+DEFINE_WEB_CONTENTS_USER_DATA_KEY(PermissionRequestManager);
 
-PermissionBubbleManager::PermissionBubbleManager(
+PermissionRequestManager::PermissionRequestManager(
     content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
 #if !defined(OS_ANDROID)  // No bubbles in android tests.
       view_factory_(base::Bind(&PermissionBubbleView::Create)),
 #endif
       view_(nullptr),
       main_frame_has_fully_loaded_(false),
       auto_response_for_test_(NONE),
       weak_factory_(this) {
 }
 
-PermissionBubbleManager::~PermissionBubbleManager() {
+PermissionRequestManager::~PermissionRequestManager() {
   if (view_ != NULL)
     view_->SetDelegate(NULL);
 
   for (PermissionBubbleRequest* request : requests_)
     request->RequestFinished();
   for (PermissionBubbleRequest* request : queued_requests_)
     request->RequestFinished();
   for (PermissionBubbleRequest* request : queued_frame_requests_)
     request->RequestFinished();
   for (const auto& entry : duplicate_requests_)
     entry.second->RequestFinished();
 }
 
-void PermissionBubbleManager::AddRequest(PermissionBubbleRequest* request) {
+void PermissionRequestManager::AddRequest(PermissionBubbleRequest* request) {
   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()));
@@ skipping 32 matching lines @@
     accept_states_.push_back(true);
   } else {
     content::RecordAction(
         base::UserMetricsAction("PermissionBubbleIFrameRequestQueued"));
     queued_frame_requests_.push_back(request);
   }
 
   ScheduleShowBubble();
 }
 
-void PermissionBubbleManager::CancelRequest(PermissionBubbleRequest* request) {
+void PermissionRequestManager::CancelRequest(PermissionBubbleRequest* request) {
   // First look in the queued requests, where we can simply finish the request
   // and go on.
   std::vector<PermissionBubbleRequest*>::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;
@@ skipping 49 matching lines @@
     if (request == it->second) {
       it->second->RequestFinished();
       duplicate_requests_.erase(it);
       return;
     }
   }
 
   NOTREACHED();  // Callers should not cancel requests that are not pending.
 }
 
-void PermissionBubbleManager::HideBubble() {
+void PermissionRequestManager::HideBubble() {
   // Disengage from the existing view if there is one.
   if (!view_)
     return;
 
   view_->SetDelegate(nullptr);
   view_->Hide();
   view_.reset();
 }
 
-void PermissionBubbleManager::DisplayPendingRequests() {
+void PermissionRequestManager::DisplayPendingRequests() {
   if (IsBubbleVisible())
     return;
 
 #if defined(OS_ANDROID)
   NOTREACHED();
   return;
 #else
   view_ = view_factory_.Run(chrome::FindBrowserWithWebContents(web_contents()));
   view_->SetDelegate(this);
 #endif
 
   TriggerShowBubble();
 }
 
-void PermissionBubbleManager::UpdateAnchorPosition() {
+void PermissionRequestManager::UpdateAnchorPosition() {
   if (view_)
     view_->UpdateAnchorPosition();
 }
 
-bool PermissionBubbleManager::IsBubbleVisible() {
+bool PermissionRequestManager::IsBubbleVisible() {
   return view_ && view_->IsVisible();
 }
 
-gfx::NativeWindow PermissionBubbleManager::GetBubbleWindow() {
+gfx::NativeWindow PermissionRequestManager::GetBubbleWindow() {
   if (view_)
     return view_->GetNativeWindow();
   return nullptr;
 }
 
-void PermissionBubbleManager::DidNavigateMainFrame(
+void PermissionRequestManager::DidNavigateMainFrame(
     const content::LoadCommittedDetails& details,
     const content::FrameNavigateParams& params) {
   if (details.is_in_page)
     return;
 
   CancelPendingQueues();
   FinalizeBubble();
   main_frame_has_fully_loaded_ = false;
 }
 
-void PermissionBubbleManager::DocumentOnLoadCompletedInMainFrame() {
+void PermissionRequestManager::DocumentOnLoadCompletedInMainFrame() {
   main_frame_has_fully_loaded_ = true;
   // This is scheduled because while all calls to the browser have been
   // issued at DOMContentLoaded, they may be bouncing around in scheduled
   // callbacks finding the UI thread still. This makes sure we allow those
   // scheduled calls to AddRequest to complete before we show the page-load
   // permissions bubble.
   ScheduleShowBubble();
 }
 
-void PermissionBubbleManager::DocumentLoadedInFrame(
+void PermissionRequestManager::DocumentLoadedInFrame(
     content::RenderFrameHost* render_frame_host) {
   ScheduleShowBubble();
 }
 
-void PermissionBubbleManager::WebContentsDestroyed() {
+void PermissionRequestManager::WebContentsDestroyed() {
   // If the web contents has been destroyed, treat the bubble as cancelled.
   CancelPendingQueues();
   FinalizeBubble();
 
   // The WebContents is going away; be aggressively paranoid and delete
   // ourselves lest other parts of the system attempt to add permission bubbles
   // or use us otherwise during the destruction.
   web_contents()->RemoveUserData(UserDataKey());
   // That was the equivalent of "delete this". This object is now destroyed;
   // returning from this function is the only safe thing to do.
 }
 
-void PermissionBubbleManager::ToggleAccept(int request_index, bool new_value) {
+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 PermissionBubbleManager::Accept() {
+void PermissionRequestManager::Accept() {
   PermissionUmaUtil::PermissionPromptAccepted(requests_, accept_states_);
 
   std::vector<PermissionBubbleRequest*>::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 PermissionBubbleManager::Deny() {
+void PermissionRequestManager::Deny() {
   PermissionUmaUtil::PermissionPromptDenied(requests_);
 
   std::vector<PermissionBubbleRequest*>::iterator requests_iter;
   for (requests_iter = requests_.begin();
        requests_iter != requests_.end();
        requests_iter++) {
     PermissionDeniedIncludingDuplicates(*requests_iter);
   }
   FinalizeBubble();
 }
 
-void PermissionBubbleManager::Closing() {
+void PermissionRequestManager::Closing() {
   std::vector<PermissionBubbleRequest*>::iterator requests_iter;
   for (requests_iter = requests_.begin();
        requests_iter != requests_.end();
        requests_iter++) {
     CancelledIncludingDuplicates(*requests_iter);
   }
   FinalizeBubble();
 }
 
-void PermissionBubbleManager::ScheduleShowBubble() {
+void PermissionRequestManager::ScheduleShowBubble() {
   // ::ScheduleShowBubble() will be called again when the main frame will be
   // loaded.
   if (!main_frame_has_fully_loaded_)
     return;
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
-      base::Bind(&PermissionBubbleManager::TriggerShowBubble,
+      base::Bind(&PermissionRequestManager::TriggerShowBubble,
                  weak_factory_.GetWeakPtr()));
 }
 
-void PermissionBubbleManager::TriggerShowBubble() {
+void PermissionRequestManager::TriggerShowBubble() {
   if (!view_)
     return;
   if (IsBubbleVisible())
     return;
   if (!main_frame_has_fully_loaded_)
     return;
   if (requests_.empty() && queued_requests_.empty() &&
       queued_frame_requests_.empty()) {
     return;
   }
@@ skipping 10 matching lines @@
 
   view_->Show(requests_, accept_states_);
   PermissionUmaUtil::PermissionPromptShown(requests_);
   NotifyBubbleAdded();
 
   // If in testing mode, automatically respond to the bubble that was shown.
   if (auto_response_for_test_ != NONE)
     DoAutoResponseForTesting();
 }
 
-void PermissionBubbleManager::FinalizeBubble() {
+void PermissionRequestManager::FinalizeBubble() {
   if (view_)
     view_->Hide();
 
   std::vector<PermissionBubbleRequest*>::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 PermissionBubbleManager::CancelPendingQueues() {
+void PermissionRequestManager::CancelPendingQueues() {
   std::vector<PermissionBubbleRequest*>::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* PermissionBubbleManager::GetExistingRequest(
+PermissionBubbleRequest* PermissionRequestManager::GetExistingRequest(
     PermissionBubbleRequest* request) {
   for (PermissionBubbleRequest* existing_request : requests_)
     if (IsMessageTextEqual(existing_request, request))
       return existing_request;
   for (PermissionBubbleRequest* existing_request : queued_requests_)
     if (IsMessageTextEqual(existing_request, request))
       return existing_request;
   for (PermissionBubbleRequest* existing_request : queued_frame_requests_)
     if (IsMessageTextEqual(existing_request, request))
       return existing_request;
   return nullptr;
 }
 
-void PermissionBubbleManager::PermissionGrantedIncludingDuplicates(
+void PermissionRequestManager::PermissionGrantedIncludingDuplicates(
     PermissionBubbleRequest* 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 PermissionBubbleManager::PermissionDeniedIncludingDuplicates(
+void PermissionRequestManager::PermissionDeniedIncludingDuplicates(
     PermissionBubbleRequest* 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 PermissionBubbleManager::CancelledIncludingDuplicates(
+void PermissionRequestManager::CancelledIncludingDuplicates(
     PermissionBubbleRequest* 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 PermissionBubbleManager::RequestFinishedIncludingDuplicates(
+void PermissionRequestManager::RequestFinishedIncludingDuplicates(
     PermissionBubbleRequest* 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.
   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 PermissionBubbleManager::AddObserver(Observer* observer) {
+void PermissionRequestManager::AddObserver(Observer* observer) {
   observer_list_.AddObserver(observer);
 }
 
-void PermissionBubbleManager::RemoveObserver(Observer* observer) {
+void PermissionRequestManager::RemoveObserver(Observer* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
-void PermissionBubbleManager::NotifyBubbleAdded() {
+void PermissionRequestManager::NotifyBubbleAdded() {
   FOR_EACH_OBSERVER(Observer, observer_list_, OnBubbleAdded());
 }
 
-void PermissionBubbleManager::DoAutoResponseForTesting() {
+void PermissionRequestManager::DoAutoResponseForTesting() {
   switch (auto_response_for_test_) {
     case ACCEPT_ALL:
       Accept();
       break;
     case DENY_ALL:
       Deny();
       break;
     case DISMISS:
       Closing();
       break;
     case NONE:
       NOTREACHED();
   }
 }