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) {

[raymes, 2017/07/20 05:21:17]

We will have to update this when someone adds a new request type :( Probably
should remove the default: so people are reminded.

I still think the benefits of using the CST outweigh using PRT here but if you
really think this is better then we can land it now and revisit it if it ever
becomes problematic.

[Timothy Loh, 2017/07/20 06:09:33]

Yeah it's not great but let's run with this for now.

+  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";

[raymes, 2017/07/20 05:21:17]

Another downside to this is it's really easy to get these strings wrong :( This
says ProtectedMedia in the enums.xml file. I've seen it happen in the past too. 

[Timothy Loh, 2017/07/20 06:09:33]

augh... fixed and removed the unused DurableStorage from histograms

+    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 307 matching lines @@
                             requests.size(), 10);
 
   if (requests.size() > 1) {
     for (const auto* request : requests) {
       PERMISSION_BUBBLE_TYPE_UMA(kPermissionsPromptMergedBubbleTypes,
                                  request->GetPermissionRequestType());
     }
   }
 }
 
-void PermissionUmaUtil::PermissionPromptAccepted(
-    const std::vector<PermissionRequest*>& requests) {
-  RecordPromptDecided(requests, /*accepted=*/true);
-}
-
-void PermissionUmaUtil::PermissionPromptDenied(
-    const std::vector<PermissionRequest*>& requests) {
-  RecordPromptDecided(requests, /*accepted=*/false);
+void PermissionUmaUtil::PermissionPromptResolved(
+    const std::vector<PermissionRequest*>& requests,
+    const content::WebContents* web_contents,
+    PermissionAction permission_action) {
+  switch (permission_action) {
+    case PermissionAction::GRANTED:
+      RecordPromptDecided(requests, /*accepted=*/true);
+      RecordEngagementMetric(requests, web_contents, "Accepted");
+      break;
+    case PermissionAction::DENIED:
+      RecordPromptDecided(requests, /*accepted=*/false);
+      RecordEngagementMetric(requests, web_contents, "Denied");
+      break;
+    case PermissionAction::DISMISSED:
+      RecordEngagementMetric(requests, web_contents, "Dismissed");
+      break;
+    case PermissionAction::IGNORED:
+      RecordEngagementMetric(requests, web_contents, "Ignored");
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
 }
 
 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);
   }
 }