Bug 1543807 - Part 1: Modify launcher process telemetry to be gated on datareporting.healthreport.uploadEnabled; r=mhowell

Differential Revision: https://phabricator.services.mozilla.com/D29543

--HG--
extra : moz-landing-system : lando

Author: dblohm7

browser/app/winlauncher/ErrorHandler.cpp

@@ -683,13 +683,9 @@ static bool SendPing(const mozilla::LauncherError& aError) {
 #if defined(MOZ_TELEMETRY_REPORTING)
 #  if defined(MOZ_LAUNCHER_PROCESS)
   mozilla::LauncherRegistryInfo regInfo;
-  mozilla::LauncherResult<mozilla::LauncherRegistryInfo::EnabledState>
-      launcherEnabled = regInfo.IsEnabled();
-  if (launcherEnabled.isErr() ||
-      launcherEnabled.unwrap() ==
-          mozilla::LauncherRegistryInfo::EnabledState::ForceDisabled) {
-    // If the launcher is force disabled, we do not send any pings
-    // (since studies and thus telemetry have been opted out)
+  mozilla::LauncherResult<bool> telemetryEnabled = regInfo.IsTelemetryEnabled();
+  if (telemetryEnabled.isErr() || !telemetryEnabled.unwrap()) {
+    // Do not send anything if telemetry has been opted out
     return false;
   }
 #  endif  // defined(MOZ_LAUNCHER_PROCESS)

toolkit/xre/LauncherRegistryInfo.cpp

@@ -24,6 +24,7 @@ const wchar_t LauncherRegistryInfo::kLauncherSubKeyPath[] =
 const wchar_t LauncherRegistryInfo::kLauncherSuffix[] = L"|Launcher";
 const wchar_t LauncherRegistryInfo::kBrowserSuffix[] = L"|Browser";
 const wchar_t LauncherRegistryInfo::kImageTimestampSuffix[] = L"|Image";
+const wchar_t LauncherRegistryInfo::kTelemetrySuffix[] = L"|Telemetry";
 
 LauncherResult<LauncherRegistryInfo::Disposition> LauncherRegistryInfo::Open() {
   if (!!mRegKey) {
@@ -93,6 +94,27 @@ LauncherVoidResult LauncherRegistryInfo::ReflectPrefToRegistry(
   return Ok();
 }
 
+LauncherVoidResult LauncherRegistryInfo::ReflectTelemetryPrefToRegistry(
+    const bool aEnable) {
+  LauncherResult<Disposition> disposition = Open();
+  if (disposition.isErr()) {
+    return LAUNCHER_ERROR_FROM_RESULT(disposition);
+  }
+
+  std::wstring valueName(ResolveTelemetryValueName());
+
+  DWORD value = aEnable ? 1UL : 0UL;
+  DWORD len = sizeof(value);
+  LSTATUS result = ::RegSetValueExW(mRegKey.get(), valueName.c_str(), 0,
+                                    REG_DWORD, reinterpret_cast<PBYTE>(&value),
+                                    len);
+  if (result != ERROR_SUCCESS) {
+    return LAUNCHER_ERROR_FROM_WIN32(result);
+  }
+
+  return Ok();
+}
+
 LauncherResult<LauncherRegistryInfo::ProcessType> LauncherRegistryInfo::Check(
     const ProcessType aDesiredType) {
   LauncherResult<Disposition> disposition = Open();
@@ -235,6 +257,15 @@ LauncherRegistryInfo::IsEnabled() {
   return EnabledState::FailDisabled;
 }
 
+LauncherResult<bool> LauncherRegistryInfo::IsTelemetryEnabled() {
+  LauncherResult<Disposition> disposition = Open();
+  if (disposition.isErr()) {
+    return LAUNCHER_ERROR_FROM_RESULT(disposition);
+  }
+
+  return GetTelemetrySetting();
+}
+
 LauncherResult<std::wstring> LauncherRegistryInfo::ResolveValueName(
     LauncherRegistryInfo::ProcessType aProcessType) {
   if (aProcessType == ProcessType::Launcher) {
@@ -267,6 +298,16 @@ std::wstring LauncherRegistryInfo::ResolveImageTimestampValueName() {
   return mImageValueName;
 }
 
+std::wstring LauncherRegistryInfo::ResolveTelemetryValueName() {
+  if (mTelemetryValueName.empty()) {
+    mTelemetryValueName.assign(mBinPath);
+    mTelemetryValueName.append(kTelemetrySuffix,
+                               ArrayLength(kTelemetrySuffix) - 1);
+  }
+
+  return mTelemetryValueName;
+}
+
 LauncherVoidResult LauncherRegistryInfo::WriteStartTimestamp(
     LauncherRegistryInfo::ProcessType aProcessType,
     const Maybe<uint64_t>& aValue) {
@@ -390,6 +431,31 @@ LauncherResult<DWORD> LauncherRegistryInfo::GetSavedImageTimestamp() {
   return value;
 }
 
+LauncherResult<bool> LauncherRegistryInfo::GetTelemetrySetting() {
+  std::wstring telemetryValueName = ResolveTelemetryValueName();
+
+  DWORD value;
+  DWORD valueLen = sizeof(value);
+  DWORD type;
+  LSTATUS result = ::RegQueryValueExW(
+      mRegKey.get(), telemetryValueName.c_str(), nullptr, &type,
+      reinterpret_cast<PBYTE>(&value), &valueLen);
+  if (result == ERROR_FILE_NOT_FOUND) {
+    // Value does not exist, treat as false
+    return false;
+  }
+
+  if (result != ERROR_SUCCESS) {
+    return LAUNCHER_ERROR_FROM_WIN32(result);
+  }
+
+  if (type != REG_DWORD) {
+    return LAUNCHER_ERROR_FROM_WIN32(ERROR_DATATYPE_MISMATCH);
+  }
+
+  return value != 0;
+}
+
 LauncherResult<uint64_t> LauncherRegistryInfo::GetStartTimestamp(
     LauncherRegistryInfo::ProcessType aProcessType) {
   LauncherResult<std::wstring> name = ResolveValueName(aProcessType);

toolkit/xre/LauncherRegistryInfo.h

@@ -36,6 +36,8 @@ class LauncherRegistryInfo final {
 
   LauncherVoidResult ReflectPrefToRegistry(const bool aEnable);
   LauncherResult<EnabledState> IsEnabled();
+  LauncherResult<bool> IsTelemetryEnabled();
+  LauncherVoidResult ReflectTelemetryPrefToRegistry(const bool aEnable);
   LauncherResult<ProcessType> Check(const ProcessType aDesiredType);
   LauncherVoidResult DisableDueToFailure();
 
@@ -52,21 +54,25 @@ class LauncherRegistryInfo final {
   LauncherVoidResult ClearStartTimestamps();
   LauncherResult<DWORD> GetSavedImageTimestamp();
   LauncherResult<uint64_t> GetStartTimestamp(ProcessType aProcessType);
+  LauncherResult<bool> GetTelemetrySetting();
 
   LauncherResult<std::wstring> ResolveValueName(ProcessType aProcessType);
   std::wstring ResolveImageTimestampValueName();
+  std::wstring ResolveTelemetryValueName();
 
  private:
   nsAutoRegKey mRegKey;
   std::wstring mBinPath;
   std::wstring mImageValueName;
   std::wstring mBrowserValueName;
   std::wstring mLauncherValueName;
+  std::wstring mTelemetryValueName;
 
   static const wchar_t kLauncherSubKeyPath[];
   static const wchar_t kLauncherSuffix[];
   static const wchar_t kBrowserSuffix[];
   static const wchar_t kImageTimestampSuffix[];
+  static const wchar_t kTelemetrySuffix[];
 };
 
 }  // namespace mozilla

toolkit/xre/nsAppRunner.cpp

@@ -246,6 +246,11 @@ extern void InstallSignalHandlers(const char* ProgramName);
 #define FILE_INVALIDATE_CACHES NS_LITERAL_CSTRING(".purgecaches")
 #define FILE_STARTUP_INCOMPLETE NS_LITERAL_STRING(".startup-incomplete")
 
+#if defined(MOZ_BLOCK_PROFILE_DOWNGRADE) || defined(MOZ_LAUNCHER_PROCESS)
+static const char kPrefHealthReportUploadEnabled[] =
+  "datareporting.healthreport.uploadEnabled";
+#endif  // defined(MOZ_BLOCK_PROFILE_DOWNGRADE) || defined(MOZ_LAUNCHER_PROCESS)
+
 int gArgc;
 char** gArgv;
 
@@ -1509,30 +1514,25 @@ static void RegisterApplicationRestartChanged(const char* aPref, void* aData) {
 
 #  if defined(MOZ_LAUNCHER_PROCESS)
 
-static const char kShieldPrefName[] = "app.shield.optoutstudies.enabled";
-
 static void OnLauncherPrefChanged(const char* aPref, void* aData) {
-  const bool kLauncherPrefDefaultValue =
-#    if defined(NIGHTLY_BUILD) || (MOZ_UPDATE_CHANNEL == beta)
-      true
-#    else
-      false
-#    endif  // defined(NIGHTLY_BUILD) || (MOZ_UPDATE_CHANNEL == beta)
-      ;
-  bool prefVal = Preferences::GetBool(kShieldPrefName, false) &&
-                 Preferences::GetBool(PREF_WIN_LAUNCHER_PROCESS_ENABLED,
-                                      kLauncherPrefDefaultValue);
+  bool prefVal = Preferences::GetBool(PREF_WIN_LAUNCHER_PROCESS_ENABLED, true);
 
   mozilla::LauncherRegistryInfo launcherRegInfo;
   mozilla::LauncherVoidResult reflectResult =
       launcherRegInfo.ReflectPrefToRegistry(prefVal);
   MOZ_ASSERT(reflectResult.isOk());
 }
 
-static void SetupLauncherProcessPref() {
-  // In addition to the launcher pref itself, we also tie the launcher process
-  // state to the SHIELD opt-out pref.
+static void OnLauncherTelemetryPrefChanged(const char* aPref, void* aData) {
+  bool prefVal = Preferences::GetBool(kPrefHealthReportUploadEnabled, true);
+
+  mozilla::LauncherRegistryInfo launcherRegInfo;
+  mozilla::LauncherVoidResult reflectResult =
+      launcherRegInfo.ReflectTelemetryPrefToRegistry(prefVal);
+  MOZ_ASSERT(reflectResult.isOk());
+}
 
+static void SetupLauncherProcessPref() {
   if (gLauncherProcessState) {
     // We've already successfully run
     return;
@@ -1550,28 +1550,22 @@ static void SetupLauncherProcessPref() {
         CrashReporter::Annotation::LauncherProcessState,
         static_cast<uint32_t>(enabledState.unwrap()));
 
-#    if defined(NIGHTLY_BUILD) || (MOZ_UPDATE_CHANNEL == beta)
-    // Reflect the pref states into the registry by calling
-    // OnLauncherPrefChanged.
-    OnLauncherPrefChanged(PREF_WIN_LAUNCHER_PROCESS_ENABLED, nullptr);
-
-    // Now obtain the revised state of the launcher process for reflection
-    // into prefs
-    enabledState = launcherRegInfo.IsEnabled();
-#    endif  // defined(NIGHTLY_BUILD) || (MOZ_UPDATE_CHANNEL == beta)
-  }
-
-  if (enabledState.isOk()) {
     // Reflect the launcher process registry state into user prefs
     Preferences::SetBool(
         PREF_WIN_LAUNCHER_PROCESS_ENABLED,
         enabledState.unwrap() !=
             mozilla::LauncherRegistryInfo::EnabledState::ForceDisabled);
   }
 
-  Preferences::RegisterCallback(&OnLauncherPrefChanged, kShieldPrefName);
+  mozilla::LauncherVoidResult reflectResult =
+    launcherRegInfo.ReflectTelemetryPrefToRegistry(
+      Preferences::GetBool(kPrefHealthReportUploadEnabled, true));
+  MOZ_ASSERT(reflectResult.isOk());
+
   Preferences::RegisterCallback(&OnLauncherPrefChanged,
                                 PREF_WIN_LAUNCHER_PROCESS_ENABLED);
+  Preferences::RegisterCallback(&OnLauncherTelemetryPrefChanged,
+                                kPrefHealthReportUploadEnabled);
 }
 
 #  endif  // defined(MOZ_LAUNCHER_PROCESS)
@@ -2070,8 +2064,8 @@ static void SubmitDowngradeTelemetry(const nsCString& aLastVersion,
   NS_ENSURE_TRUE_VOID(prefBranch);
 
   bool enabled;
-  nsresult rv = prefBranch->GetBoolPref(
-      "datareporting.healthreport.uploadEnabled", &enabled);
+  nsresult rv = prefBranch->GetBoolPref(kPrefHealthReportUploadEnabled,
+                                        &enabled);
   NS_ENSURE_SUCCESS_VOID(rv);
   if (!enabled) {
     return;