Log site engagement scores for permission actions

chrome/browser/permissions/permission_uma_util.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_uma_util.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/engagement/site_engagement_service.h"
 #include "chrome/browser/permissions/permission_decision_auto_blocker.h"
 #include "chrome/browser/permissions/permission_request.h"
 #include "chrome/browser/permissions/permission_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/safe_browsing/ui_manager.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "components/browser_sync/profile_sync_service.h"
 #include "components/prefs/pref_service.h"
 #include "components/rappor/public/rappor_utils.h"
 #include "components/rappor/rappor_service_impl.h"
 #include "content/public/browser/permission_type.h"
+#include "content/public/browser/web_contents.h"
 #include "content/public/common/origin_util.h"
 #include "url/gurl.h"
 
 // UMA keys need to be statically initialized so plain function would not
 // work. Use macros instead.
 #define PERMISSION_ACTION_UMA(secure_origin, permission, permission_secure, \
                               permission_insecure, action)                  \
   UMA_HISTOGRAM_ENUMERATION(permission, action, PermissionAction::NUM);     \
   if (secure_origin) {                                                      \
     UMA_HISTOGRAM_ENUMERATION(permission_secure, action,                    \
@@ skipping 17 matching lines @@
     PERMISSION_BUBBLE_TYPE_UMA(no_gesture_metric_name,                       \
                                permission_bubble_type);                      \
   }
 
 using content::PermissionType;
 
 namespace {
 
 static bool gIsFakeOfficialBuildForTest = false;
 
+std::string GetPermissionRequestString(PermissionRequestType type) {
+  switch (type) {
+    case PermissionRequestType::MULTIPLE:
+      return "AudioAndVideoCapture";
+    case PermissionRequestType::QUOTA:
+      return "Quota";
+    case PermissionRequestType::DOWNLOAD:
+      return "MultipleDownload";
+    case PermissionRequestType::REGISTER_PROTOCOL_HANDLER:
+      return "RegisterProtocolHandler";
+    case PermissionRequestType::PERMISSION_GEOLOCATION:
+      return "Geolocation";
+    case PermissionRequestType::PERMISSION_MIDI_SYSEX:
+      return "MidiSysEx";
+    case PermissionRequestType::PERMISSION_NOTIFICATIONS:
+      return "Notifications";
+    case PermissionRequestType::PERMISSION_PROTECTED_MEDIA_IDENTIFIER:
+      return "ProtectedMediaIdentifier";
+    case PermissionRequestType::PERMISSION_PUSH_MESSAGING:
+      return "PushMessaging";
+    case PermissionRequestType::PERMISSION_FLASH:
+      return "Flash";
+    case PermissionRequestType::PERMISSION_MEDIASTREAM_MIC:
+      return "AudioCapture";
+    case PermissionRequestType::PERMISSION_MEDIASTREAM_CAMERA:
+      return "VideoCapture";
+    default:
+      NOTREACHED();
+      return "";
+  }
+}
+
+void RecordEngagementMetric(const std::vector<PermissionRequest*>& requests,
+                            const content::WebContents* web_contents,
+                            const std::string& action) {
+  PermissionRequestType type = requests[0]->GetPermissionRequestType();
+  if (requests.size() > 1)
+    type = PermissionRequestType::MULTIPLE;
+
+  // This is only hit if kUsePermissionManagerForMediaRequests is off, since it
+  // is now on by default we'll just silenty drop this.
+  if (type == PermissionRequestType::MEDIA_STREAM)
+    return;
+
+  DCHECK(action == "Accepted" || action == "Denied" || action == "Dismissed" ||
+         action == "Ignored");
+  std::string name = "Permissions.Engagement." + action + '.' +
+                     GetPermissionRequestString(type);
+
+  SiteEngagementService* site_engagement_service = SiteEngagementService::Get(
+      Profile::FromBrowserContext(web_contents->GetBrowserContext()));
+  double engagement_score =
+      site_engagement_service->GetScore(requests[0]->GetOrigin());
+
+  // This is manually expanded from the UMA_HISTOGRAM_PERCENTAGE macro as the
+  // macro does not work with a dynamically calculated histogram name.
+  base::LinearHistogram::FactoryGet(
+      name, 1, 101, 102, base::HistogramBase::kUmaTargetedHistogramFlag)
+      ->Add(engagement_score);
+}
+
 const std::string GetRapporMetric(ContentSettingsType permission,
                                   PermissionAction action) {
   std::string action_str;
   switch (action) {
     case PermissionAction::GRANTED:
       action_str = "Granted";
       break;
     case PermissionAction::DENIED:
       action_str = "Denied";
       break;
@@ skipping 308 matching lines @@
 
   if (requests.size() > 1) {
     for (const auto* request : requests) {
       PERMISSION_BUBBLE_TYPE_UMA(kPermissionsPromptMergedBubbleTypes,
                                  request->GetPermissionRequestType());
     }
   }
 }
 
 void PermissionUmaUtil::PermissionPromptAccepted(
-    const std::vector<PermissionRequest*>& requests) {
+    const std::vector<PermissionRequest*>& requests,
+    const content::WebContents* web_contents) {
   RecordPromptDecided(requests, /*accepted=*/true);
+  RecordEngagementMetric(requests, web_contents, "Accepted");
 }
 
 void PermissionUmaUtil::PermissionPromptDenied(
-    const std::vector<PermissionRequest*>& requests) {
+    const std::vector<PermissionRequest*>& requests,
+    const content::WebContents* web_contents) {
   RecordPromptDecided(requests, /*accepted=*/false);
+  RecordEngagementMetric(requests, web_contents, "Denied");
+}
+
+void PermissionUmaUtil::PermissionPromptDismissed(
+    const std::vector<PermissionRequest*>& requests,
+    const content::WebContents* web_contents) {
+  RecordEngagementMetric(requests, web_contents, "Dismissed");
+}
+
+void PermissionUmaUtil::PermissionPromptIgnored(
+    const std::vector<PermissionRequest*>& requests,
+    const content::WebContents* web_contents) {
+  RecordEngagementMetric(requests, web_contents, "Ignored");
 }
 
 void PermissionUmaUtil::RecordPermissionPromptShown(
     PermissionRequestType request_type,
     PermissionRequestGestureType gesture_type) {
   PERMISSION_BUBBLE_TYPE_UMA(kPermissionsPromptShown, request_type);
   PERMISSION_BUBBLE_GESTURE_TYPE_UMA(
       kPermissionsPromptShownGesture, kPermissionsPromptShownNoGesture,
       gesture_type, request_type);
 }
@@ skipping 296 matching lines @@
   }
 
   if (accepted) {
     RecordPermissionPromptAccepted(permission_prompt_type,
                                    permission_gesture_type);
   } else {
     RecordPermissionPromptDenied(permission_prompt_type,
                                  permission_gesture_type);
   }
 }