Reland add hooks to permission layer for permission action reporting

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 "chrome/browser/browser_process.h"
 #include "chrome/browser/permissions/permission_manager.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/browser/ui/website_settings/permission_bubble_request.h"
+#include "chrome/common/chrome_switches.h"
+#include "chrome/common/pref_names.h"
+#include "components/browser_sync/browser/profile_sync_service.h"
+#include "components/prefs/pref_service.h"
 #include "components/rappor/rappor_service.h"
 #include "components/rappor/rappor_utils.h"
 #include "content/public/browser/permission_type.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)                  \
@@ skipping 41 matching lines @@
   }
 
   std::string permission_str =
       PermissionUtil::GetPermissionString(permission);
   if (permission_str.empty())
     return "";
   return base::StringPrintf("ContentSettings.PermissionActions_%s.%s.Url",
                             permission_str.c_str(), action_str.c_str());
 }
 
-void RecordPermissionAction(PermissionType permission,
-                            PermissionAction action,
-                            const GURL& requesting_origin) {
-  bool secure_origin = content::IsOriginSecure(requesting_origin);
-
-  switch (permission) {
-    case PermissionType::GEOLOCATION:
-        PERMISSION_ACTION_UMA(
-            secure_origin,
-            "Permissions.Action.Geolocation",
-            "Permissions.Action.SecureOrigin.Geolocation",
-            "Permissions.Action.InsecureOrigin.Geolocation",
-            action);
-        break;
-    case PermissionType::NOTIFICATIONS:
-        PERMISSION_ACTION_UMA(
-            secure_origin,
-            "Permissions.Action.Notifications",
-            "Permissions.Action.SecureOrigin.Notifications",
-            "Permissions.Action.InsecureOrigin.Notifications",
-            action);
-        break;
-    case PermissionType::MIDI_SYSEX:
-        PERMISSION_ACTION_UMA(
-            secure_origin,
-            "Permissions.Action.MidiSysEx",
-            "Permissions.Action.SecureOrigin.MidiSysEx",
-            "Permissions.Action.InsecureOrigin.MidiSysEx",
-            action);
-        break;
-    case PermissionType::PUSH_MESSAGING:
-        PERMISSION_ACTION_UMA(
-            secure_origin,
-            "Permissions.Action.PushMessaging",
-            "Permissions.Action.SecureOrigin.PushMessaging",
-            "Permissions.Action.InsecureOrigin.PushMessaging",
-            action);
-        break;
-    case PermissionType::PROTECTED_MEDIA_IDENTIFIER:
-        PERMISSION_ACTION_UMA(
-            secure_origin,
-            "Permissions.Action.ProtectedMedia",
-            "Permissions.Action.SecureOrigin.ProtectedMedia",
-            "Permissions.Action.InsecureOrigin.ProtectedMedia",
-            action);
-        break;
-    case PermissionType::DURABLE_STORAGE:
-        PERMISSION_ACTION_UMA(
-            secure_origin,
-            "Permissions.Action.DurableStorage",
-            "Permissions.Action.SecureOrigin.DurableStorage",
-            "Permissions.Action.InsecureOrigin.DurableStorage",
-            action);
-        break;
-    case PermissionType::AUDIO_CAPTURE:
-        // Media permissions are disabled on insecure origins, so there's no
-        // need to record metrics for secure/insecue.
-        UMA_HISTOGRAM_ENUMERATION("Permissions.Action.AudioCapture", action,
-                                  PERMISSION_ACTION_NUM);
-        break;
-    case PermissionType::VIDEO_CAPTURE:
-        UMA_HISTOGRAM_ENUMERATION("Permissions.Action.VideoCapture", action,
-                                  PERMISSION_ACTION_NUM);
-        break;
-    // The user is not prompted for these permissions, thus there is no
-    // permission action recorded for them.
-    case PermissionType::MIDI:
-    case PermissionType::BACKGROUND_SYNC:
-    case PermissionType::NUM:
-      NOTREACHED() << "PERMISSION "
-                   << PermissionUtil::GetPermissionString(permission)
-                   << " not accounted for";
-  }
-
-  // Retrieve the name of the RAPPOR metric. Currently, the new metric name is
-  // the deprecated name with "2" on the end, e.g.
-  // ContentSettings.PermissionActions_Geolocation.Granted.Url2. For simplicity,
-  // we retrieve the deprecated name and append the "2" for the new name.
-  // TODO(dominickn): remove the deprecated metric and replace it solely with
-  // the new one in GetRapporMetric - crbug.com/605836.
-  const std::string deprecated_metric = GetRapporMetric(permission, action);
-  rappor::RapporService* rappor_service = g_browser_process->rappor_service();
-  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));
-  }
-}
-
 void RecordPermissionRequest(PermissionType permission,
                              const GURL& requesting_origin,
                              const GURL& embedding_origin,
                              Profile* profile) {
   rappor::RapporService* rappor_service = g_browser_process->rappor_service();
   if (rappor_service) {
     if (permission == PermissionType::GEOLOCATION) {
       // TODO(dominickn): remove this deprecated metric - crbug.com/605836.
       rappor::SampleDomainAndRegistryFromGURL(
           rappor_service,
@@ skipping 93 matching lines @@
 // add new permission
 void PermissionUmaUtil::PermissionRequested(PermissionType permission,
                                             const GURL& requesting_origin,
                                             const GURL& embedding_origin,
                                             Profile* profile) {
   RecordPermissionRequest(permission, requesting_origin, embedding_origin,
                           profile);
 }
 
 void PermissionUmaUtil::PermissionGranted(PermissionType permission,
-                                          const GURL& requesting_origin) {
-  RecordPermissionAction(permission, GRANTED, requesting_origin);
+                                          const GURL& requesting_origin,
+                                          Profile* profile) {
+  RecordPermissionAction(permission, GRANTED, requesting_origin, profile);
 }
 
 void PermissionUmaUtil::PermissionDenied(PermissionType permission,
-                                         const GURL& requesting_origin) {
-  RecordPermissionAction(permission, DENIED, requesting_origin);
+                                         const GURL& requesting_origin,
+                                         Profile* profile) {
+  RecordPermissionAction(permission, DENIED, requesting_origin, profile);
 }
 
 void PermissionUmaUtil::PermissionDismissed(PermissionType permission,
-                                            const GURL& requesting_origin) {
-  RecordPermissionAction(permission, DISMISSED, requesting_origin);
+                                            const GURL& requesting_origin,
+                                            Profile* profile) {
+  RecordPermissionAction(permission, DISMISSED, requesting_origin, profile);
 }
 
 void PermissionUmaUtil::PermissionIgnored(PermissionType permission,
-                                          const GURL& requesting_origin) {
-  RecordPermissionAction(permission, IGNORED, requesting_origin);
+                                          const GURL& requesting_origin,
+                                          Profile* profile) {
+  RecordPermissionAction(permission, IGNORED, requesting_origin, profile);
 }
 
 void PermissionUmaUtil::PermissionRevoked(PermissionType permission,
-                                          const GURL& revoked_origin) {
+                                          const GURL& revoked_origin,
+                                          Profile* profile) {
   // TODO(tsergeant): Expand metrics definitions for revocation to include all
   // permissions.
   if (permission == PermissionType::NOTIFICATIONS ||
       permission == PermissionType::GEOLOCATION ||
       permission == PermissionType::AUDIO_CAPTURE ||
       permission == PermissionType::VIDEO_CAPTURE) {
-    RecordPermissionAction(permission, REVOKED, revoked_origin);
+    RecordPermissionAction(permission, REVOKED, revoked_origin, profile);
   }
 }
 
 void PermissionUmaUtil::PermissionPromptShown(
     const std::vector<PermissionBubbleRequest*>& requests) {
   DCHECK(!requests.empty());
 
   PermissionBubbleType permission_prompt_type = PermissionBubbleType::MULTIPLE;
   if (requests.size() == 1)
     permission_prompt_type = requests[0]->GetPermissionBubbleType();
@@ skipping 46 matching lines @@
 }
 
 void PermissionUmaUtil::PermissionPromptDenied(
     const std::vector<PermissionBubbleRequest*>& requests) {
   DCHECK(!requests.empty());
   DCHECK(requests.size() == 1);
 
   PERMISSION_BUBBLE_TYPE_UMA(kPermissionsPromptDenied,
                              requests[0]->GetPermissionBubbleType());
 }
+
+bool PermissionUmaUtil::IsOptedIntoPermissionActionReporting(Profile* profile) {
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnablePermissionActionReporting))
+    return false;
+  // TODO(stefanocs): Remove this check once all callsites have been updated
+  // to not pass a nullptr.
+  if (!profile)
+    return false;
+  if (profile->GetProfileType() == Profile::INCOGNITO_PROFILE)
+    return false;
+  if (!profile->GetPrefs()->GetBoolean(prefs::kSafeBrowsingEnabled))
+    return false;
+
+  ProfileSyncService* profile_sync_service =
+      ProfileSyncServiceFactory::GetForProfile(profile);
+
+  // Do not report if profile can't get a profile sync service due to disable
+  // sync flag.
+  if (!profile_sync_service)
+    return false;
+
+  if (!profile_sync_service->CanSyncStart())
+    return false;
+
+  syncer::ModelTypeSet preferred_data_types =
+      profile_sync_service->GetPreferredDataTypes();
+  if (!preferred_data_types.Has(syncer::PROXY_TABS))
+    return false;
+  if (!preferred_data_types.Has(syncer::PRIORITY_PREFERENCES))
+    return false;
+
+  return true;
+}
+
+void PermissionUmaUtil::RecordPermissionAction(PermissionType permission,
+                                               PermissionAction action,
+                                               const GURL& requesting_origin,
+                                               Profile* profile) {
+  if (IsOptedIntoPermissionActionReporting(profile)) {
+    // TODO(stefanocs): Add browsertests to make sure the reports are being
+    // sent.
+    g_browser_process->safe_browsing_service()
+        ->ui_manager()
+        ->ReportPermissionAction(requesting_origin, permission, action);
+  }
+
+  bool secure_origin = content::IsOriginSecure(requesting_origin);
+
+  switch (permission) {
+    case PermissionType::GEOLOCATION:
+      PERMISSION_ACTION_UMA(secure_origin, "Permissions.Action.Geolocation",
+                            "Permissions.Action.SecureOrigin.Geolocation",
+                            "Permissions.Action.InsecureOrigin.Geolocation",
+                            action);
+      break;
+    case PermissionType::NOTIFICATIONS:
+      PERMISSION_ACTION_UMA(secure_origin, "Permissions.Action.Notifications",
+                            "Permissions.Action.SecureOrigin.Notifications",
+                            "Permissions.Action.InsecureOrigin.Notifications",
+                            action);
+      break;
+    case PermissionType::MIDI_SYSEX:
+      PERMISSION_ACTION_UMA(secure_origin, "Permissions.Action.MidiSysEx",
+                            "Permissions.Action.SecureOrigin.MidiSysEx",
+                            "Permissions.Action.InsecureOrigin.MidiSysEx",
+                            action);
+      break;
+    case PermissionType::PUSH_MESSAGING:
+      PERMISSION_ACTION_UMA(secure_origin, "Permissions.Action.PushMessaging",
+                            "Permissions.Action.SecureOrigin.PushMessaging",
+                            "Permissions.Action.InsecureOrigin.PushMessaging",
+                            action);
+      break;
+    case PermissionType::PROTECTED_MEDIA_IDENTIFIER:
+      PERMISSION_ACTION_UMA(secure_origin, "Permissions.Action.ProtectedMedia",
+                            "Permissions.Action.SecureOrigin.ProtectedMedia",
+                            "Permissions.Action.InsecureOrigin.ProtectedMedia",
+                            action);
+      break;
+    case PermissionType::DURABLE_STORAGE:
+      PERMISSION_ACTION_UMA(secure_origin, "Permissions.Action.DurableStorage",
+                            "Permissions.Action.SecureOrigin.DurableStorage",
+                            "Permissions.Action.InsecureOrigin.DurableStorage",
+                            action);
+      break;
+    case PermissionType::AUDIO_CAPTURE:
+      // Media permissions are disabled on insecure origins, so there's no
+      // need to record metrics for secure/insecue.
+      UMA_HISTOGRAM_ENUMERATION("Permissions.Action.AudioCapture", action,
+                                PERMISSION_ACTION_NUM);
+      break;
+    case PermissionType::VIDEO_CAPTURE:
+      UMA_HISTOGRAM_ENUMERATION("Permissions.Action.VideoCapture", action,
+                                PERMISSION_ACTION_NUM);
+      break;
+    // The user is not prompted for these permissions, thus there is no
+    // permission action recorded for them.
+    case PermissionType::MIDI:
+    case PermissionType::BACKGROUND_SYNC:
+    case PermissionType::NUM:
+      NOTREACHED() << "PERMISSION "
+                   << PermissionUtil::GetPermissionString(permission)
+                   << " not accounted for";
+  }
+
+  // Retrieve the name of the RAPPOR metric. Currently, the new metric name is
+  // the deprecated name with "2" on the end, e.g.
+  // ContentSettings.PermissionActions_Geolocation.Granted.Url2. For simplicity,
+  // we retrieve the deprecated name and append the "2" for the new name.
+  // TODO(dominickn): remove the deprecated metric and replace it solely with
+  // the new one in GetRapporMetric - crbug.com/605836.
+  const std::string deprecated_metric = GetRapporMetric(permission, action);
+  rappor::RapporService* rappor_service = g_browser_process->rappor_service();
+  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));
+  }
+}