Record metrics for permission prompt acceptance vs. user gesture.

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"
@@ skipping 22 matching lines @@
                               permission_insecure, action)                  \
   UMA_HISTOGRAM_ENUMERATION(permission, action, PERMISSION_ACTION_NUM);     \
   if (secure_origin) {                                                      \
     UMA_HISTOGRAM_ENUMERATION(permission_secure, action,                    \
                               PERMISSION_ACTION_NUM);                       \
   } else {                                                                  \
     UMA_HISTOGRAM_ENUMERATION(permission_insecure, action,                  \
                               PERMISSION_ACTION_NUM);                       \
   }
 
-#define PERMISSION_BUBBLE_TYPE_UMA(metric_name, permission_bubble_type)      \
-    UMA_HISTOGRAM_ENUMERATION(                                               \
-        metric_name,                                                         \
-        static_cast<base::HistogramBase::Sample>(permission_bubble_type),    \
-        static_cast<base::HistogramBase::Sample>(PermissionRequestType::NUM))
+#define PERMISSION_BUBBLE_TYPE_UMA(metric_name, permission_bubble_type) \
+  UMA_HISTOGRAM_ENUMERATION(                                            \
+      metric_name,                                                      \
+      static_cast<base::HistogramBase::Sample>(permission_bubble_type), \
+      static_cast<base::HistogramBase::Sample>(PermissionRequestType::NUM))
+
+#define PERMISSION_BUBBLE_GESTURE_TYPE_UMA(gesture_metric_name,              \
+                                           no_gesture_metric_name,           \
+                                           gesture_type,                     \
+                                           permission_bubble_type)           \
+  if (gesture_type == PermissionRequestGestureType::GESTURE) {               \
+    PERMISSION_BUBBLE_TYPE_UMA(gesture_metric_name, permission_bubble_type); \
+  } else if (gesture_type == PermissionRequestGestureType::NO_GESTURE) {     \
+    PERMISSION_BUBBLE_TYPE_UMA(no_gesture_metric_name,                       \
+                               permission_bubble_type);                      \
+  }
 
 using content::PermissionType;
 
 namespace {
 
 const std::string GetRapporMetric(PermissionType permission,
                                   PermissionAction action) {
   std::string action_str;
   switch (action) {
     case GRANTED:
@@ skipping 106 matching lines @@
         "Permissions.Requested.SameOrigin",
         static_cast<base::HistogramBase::Sample>(permission),
         static_cast<base::HistogramBase::Sample>(PermissionType::NUM));
   }
 }
 
 }  // anonymous namespace
 
 const char PermissionUmaUtil::kPermissionsPromptShown[] =
     "Permissions.Prompt.Shown";
+const char PermissionUmaUtil::kPermissionsPromptShownGesture[] =
+    "Permissions.Prompt.Shown.Gesture";
+const char PermissionUmaUtil::kPermissionsPromptShownNoGesture[] =
+    "Permissions.Prompt.Shown.NoGesture";
 const char PermissionUmaUtil::kPermissionsPromptAccepted[] =
     "Permissions.Prompt.Accepted";
+const char PermissionUmaUtil::kPermissionsPromptAcceptedGesture[] =
+    "Permissions.Prompt.Accepted.Gesture";
+const char PermissionUmaUtil::kPermissionsPromptAcceptedNoGesture[] =
+    "Permissions.Prompt.Accepted.NoGesture";
 const char PermissionUmaUtil::kPermissionsPromptDenied[] =
     "Permissions.Prompt.Denied";
+const char PermissionUmaUtil::kPermissionsPromptDeniedGesture[] =
+    "Permissions.Prompt.Denied.Gesture";
+const char PermissionUmaUtil::kPermissionsPromptDeniedNoGesture[] =
+    "Permissions.Prompt.Denied.NoGesture";
 const char PermissionUmaUtil::kPermissionsPromptRequestsPerPrompt[] =
     "Permissions.Prompt.RequestsPerPrompt";
 const char PermissionUmaUtil::kPermissionsPromptMergedBubbleTypes[] =
     "Permissions.Prompt.MergedBubbleTypes";
 const char PermissionUmaUtil::kPermissionsPromptMergedBubbleAccepted[] =
     "Permissions.Prompt.MergedBubbleAccepted";
 const char PermissionUmaUtil::kPermissionsPromptMergedBubbleDenied[] =
     "Permissions.Prompt.MergedBubbleDenied";
 
 // Make sure you update histograms.xml permission histogram_suffix if you
@@ skipping 48 matching lines @@
                            profile);
   }
 }
 
 void PermissionUmaUtil::PermissionPromptShown(
     const std::vector<PermissionRequest*>& requests) {
   DCHECK(!requests.empty());
 
   PermissionRequestType permission_prompt_type =
       PermissionRequestType::MULTIPLE;
-  if (requests.size() == 1)
+  PermissionRequestGestureType permission_gesture_type =
+      PermissionRequestGestureType::UNKNOWN;
+  if (requests.size() == 1) {
     permission_prompt_type = requests[0]->GetPermissionRequestType();
+    permission_gesture_type = requests[0]->GetGestureType();
+  }
+
   PERMISSION_BUBBLE_TYPE_UMA(kPermissionsPromptShown, permission_prompt_type);
+  PERMISSION_BUBBLE_GESTURE_TYPE_UMA(
+      kPermissionsPromptShownGesture, kPermissionsPromptShownNoGesture,
+      permission_gesture_type, permission_prompt_type);
 
   UMA_HISTOGRAM_ENUMERATION(
       kPermissionsPromptRequestsPerPrompt,
       static_cast<base::HistogramBase::Sample>(requests.size()),
       static_cast<base::HistogramBase::Sample>(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,
     const std::vector<bool>& accept_states) {
   DCHECK(!requests.empty());
   DCHECK(requests.size() == accept_states.size());
 
   bool all_accepted = accept_states[0];
   PermissionRequestType permission_prompt_type =
       requests[0]->GetPermissionRequestType();
+  PermissionRequestGestureType permission_gesture_type =
+      requests[0]->GetGestureType();
   if (requests.size() > 1) {
     permission_prompt_type = PermissionRequestType::MULTIPLE;
+    permission_gesture_type = PermissionRequestGestureType::UNKNOWN;
     for (size_t i = 0; i < requests.size(); ++i) {
       const auto* request = requests[i];
       if (accept_states[i]) {
         PERMISSION_BUBBLE_TYPE_UMA(kPermissionsPromptMergedBubbleAccepted,
                                    request->GetPermissionRequestType());
       } else {
         all_accepted = false;
         PERMISSION_BUBBLE_TYPE_UMA(kPermissionsPromptMergedBubbleDenied,
                                    request->GetPermissionRequestType());
       }
     }
   }
 
   if (all_accepted) {
     PERMISSION_BUBBLE_TYPE_UMA(kPermissionsPromptAccepted,
                                permission_prompt_type);
+    PERMISSION_BUBBLE_GESTURE_TYPE_UMA(
+        kPermissionsPromptAcceptedGesture, kPermissionsPromptAcceptedNoGesture,
+        permission_gesture_type, permission_prompt_type);
   } else {
     PERMISSION_BUBBLE_TYPE_UMA(kPermissionsPromptDenied,
                                permission_prompt_type);
+    PERMISSION_BUBBLE_GESTURE_TYPE_UMA(
+        kPermissionsPromptDeniedGesture, kPermissionsPromptDeniedNoGesture,
+        permission_gesture_type, permission_prompt_type);
   }
 }
 
 void PermissionUmaUtil::PermissionPromptDenied(
     const std::vector<PermissionRequest*>& requests) {
   DCHECK(!requests.empty());
   DCHECK(requests.size() == 1);
 
   PERMISSION_BUBBLE_TYPE_UMA(kPermissionsPromptDenied,
                              requests[0]->GetPermissionRequestType());
+  PERMISSION_BUBBLE_GESTURE_TYPE_UMA(
+      kPermissionsPromptDeniedGesture, kPermissionsPromptDeniedNoGesture,
+      requests[0]->GetGestureType(), requests[0]->GetPermissionRequestType());
 }
 
 bool PermissionUmaUtil::IsOptedIntoPermissionActionReporting(Profile* profile) {
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnablePermissionActionReporting))
     return false;
 
   DCHECK(profile);
   if (profile->GetProfileType() == Profile::INCOGNITO_PROFILE)
     return false;
@@ skipping 106 matching lines @@
   if (!deprecated_metric.empty() && rappor_service) {
     rappor::SampleDomainAndRegistryFromGURL(rappor_service, deprecated_metric,
                                             requesting_origin);
 
     std::string rappor_metric = deprecated_metric + "2";
     rappor_service->RecordSample(
         rappor_metric, rappor::LOW_FREQUENCY_ETLD_PLUS_ONE_RAPPOR_TYPE,
         rappor::GetDomainAndRegistrySampleFromGURL(requesting_origin));
   }
 }