Replace PermissionType in chrome/ with ContentSettingsType

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 "build/build_config.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"
@@ skipping 35 matching lines @@
   content::WebContents* other_web_contents = tab_util::GetWebContentsByFrameID(
       other_request.render_process_id(), other_request.render_frame_id());
 
   return web_contents == other_web_contents;
 }
 
 }  // anonymous namespace
 
 class PermissionQueueController::PendingInfobarRequest {
  public:
-  PendingInfobarRequest(content::PermissionType type,
+  PendingInfobarRequest(ContentSettingsType type,
                         const PermissionRequestID& id,
                         const GURL& requesting_frame,
                         const GURL& embedder,
                         bool user_gesture,
                         Profile* profile,
                         const PermissionDecidedCallback& callback);
   ~PendingInfobarRequest();
 
   bool IsForPair(const GURL& requesting_frame,
                  const GURL& embedder) const;
@@ skipping 10 matching lines @@
   const GURL& requesting_frame() const { return requesting_frame_; }
   bool has_gesture() const { return user_gesture_; }
   bool has_infobar() const { return !!infobar_; }
   bool has_dialog() const { return has_dialog_; }
   infobars::InfoBar* infobar() { return infobar_; }
 
   void RunCallback(ContentSetting content_setting);
   void CreatePrompt(PermissionQueueController* controller, bool show_dialog);
 
  private:
-  content::PermissionType type_;
+  ContentSettingsType type_;
   PermissionRequestID id_;
   GURL requesting_frame_;
   GURL embedder_;
   bool user_gesture_;
   Profile* profile_;
   PermissionDecidedCallback callback_;
   infobars::InfoBar* infobar_;
   bool has_dialog_;
 
   // Purposefully do not disable copying, as this is stored in STL containers.
 };
 
 PermissionQueueController::PendingInfobarRequest::PendingInfobarRequest(
-    content::PermissionType type,
+    ContentSettingsType type,
     const PermissionRequestID& id,
     const GURL& requesting_frame,
     const GURL& embedder,
     bool user_gesture,
     Profile* profile,
     const PermissionDecidedCallback& callback)
     : type_(type),
       id_(id),
       requesting_frame_(requesting_frame),
       embedder_(embedder),
@@ skipping 40 matching lines @@
                                      callback);
   } else {
     infobar_ = PermissionInfoBarDelegate::Create(
         GetInfoBarService(id_), type_, 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) {}
 
 PermissionQueueController::~PermissionQueueController() {
   // Cancel all outstanding requests.
   in_shutdown_ = true;
   while (!pending_infobar_requests_.empty())
     CancelInfoBarRequest(pending_infobar_requests_.front().id());
 }
 
 void PermissionQueueController::CreateInfoBarRequest(
     const PermissionRequestID& id,
     const GURL& requesting_frame,
     const GURL& embedder,
     bool user_gesture,
     const PermissionDecidedCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   if (requesting_frame.SchemeIs(content::kChromeUIScheme) ||
       embedder.SchemeIs(content::kChromeUIScheme))
     return;
 
   pending_infobar_requests_.push_back(
-      PendingInfobarRequest(permission_type_, id, requesting_frame, embedder,
-                            user_gesture, profile_, callback));
+      PendingInfobarRequest(content_settings_type_, id, requesting_frame,
+                            embedder, user_gesture, profile_, callback));
   if (!AlreadyShowingInfoBarForTab(id))
     ShowQueuedInfoBarForTab(id);
 }
 
 void PermissionQueueController::CancelInfoBarRequest(
     const PermissionRequestID& id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   for (PendingInfobarRequests::iterator i(pending_infobar_requests_.begin());
        i != pending_infobar_requests_.end(); ++i) {
@@ skipping 11 matching lines @@
 
 void PermissionQueueController::OnPermissionSet(const PermissionRequestID& id,
                                                 const GURL& requesting_frame,
                                                 const GURL& embedder,
                                                 bool user_gesture,
                                                 bool update_content_setting,
                                                 PermissionAction decision) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   PermissionRequestType request_type =
-      PermissionUtil::GetRequestType(permission_type_);
+      PermissionUtil::GetRequestType(content_settings_type_);
   PermissionRequestGestureType gesture_type =
       PermissionUtil::GetGestureType(user_gesture);
   switch (decision) {
     case GRANTED:
-      PermissionUmaUtil::PermissionGranted(permission_type_, gesture_type,
+      PermissionUmaUtil::PermissionGranted(content_settings_type_, gesture_type,
                                            requesting_frame, profile_);
       PermissionUmaUtil::RecordPermissionPromptAccepted(request_type,
                                                         gesture_type);
       break;
     case DENIED:
-      PermissionUmaUtil::PermissionDenied(permission_type_, gesture_type,
+      PermissionUmaUtil::PermissionDenied(content_settings_type_, gesture_type,
                                           requesting_frame, profile_);
       PermissionUmaUtil::RecordPermissionPromptDenied(request_type,
                                                       gesture_type);
       break;
     case DISMISSED:
-      PermissionUmaUtil::PermissionDismissed(permission_type_, gesture_type,
-                                             requesting_frame, profile_);
+      PermissionUmaUtil::PermissionDismissed(
+          content_settings_type_, gesture_type, requesting_frame, profile_);
       break;
     default:
       NOTREACHED();
   }
 
   // TODO(miguelg): move the permission persistence to
   // PermissionContextBase once all the types are moved there.
   if (update_content_setting)
     UpdateContentSetting(requesting_frame, embedder, decision);
 
@@ skipping 177 matching lines @@
   if (requesting_frame.GetOrigin().SchemeIsFile()) {
     // Chrome can be launched with --disable-web-security which allows
     // geolocation requests from file:// URLs. We don't want to store these
     // in the host content settings map.
     return;
   }
 
   ContentSetting content_setting =
       (decision == GRANTED) ? CONTENT_SETTING_ALLOW : CONTENT_SETTING_BLOCK;
 
+  // TODO(timloh): Remove this logic when push and notification permissions
+  // are reconciled.

[raymes, 2017/02/09 00:39:57]

nit: you can add that bug here too

+  ContentSettingsType type_for_map = content_settings_type_;
+  if (type_for_map == CONTENT_SETTINGS_TYPE_PUSH_MESSAGING)
+    type_for_map = CONTENT_SETTINGS_TYPE_NOTIFICATIONS;
   HostContentSettingsMapFactory::GetForProfile(profile_)
       ->SetContentSettingDefaultScope(
           requesting_frame.GetOrigin(), embedder.GetOrigin(),
-          content_settings_type_, std::string(), content_setting);
+          type_for_map, std::string(), content_setting);
 }