Installer support for Windows 10 inactive user toast.

chrome/installer/util/experiment_storage.cc

 // Copyright 2017 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/installer/util/experiment_storage.h"
 
 #include <windows.h>
 
 #include <stdint.h>
 
@@ skipping 18 matching lines @@
 #include "chrome/installer/util/experiment_labels.h"
 #include "chrome/installer/util/experiment_metrics.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "chrome/installer/util/shell_util.h"
 
 namespace installer {
 
 namespace {
 
 constexpr base::char16 kExperimentLabelName[] = L"CrExp60";
-constexpr wchar_t kRegKeyRetention[] = L"Retention";
+constexpr wchar_t kRegKeyRetention[] = L"\\Retention";
 constexpr wchar_t kRegValueActionDelay[] = L"ActionDelay";
 constexpr wchar_t kRegValueFirstDisplayTime[] = L"FirstDisplayTime";
 constexpr wchar_t kRegValueGroup[] = L"Group";
 constexpr wchar_t kRegValueInactiveDays[] = L"InactiveDays";
 constexpr wchar_t kRegValueLatestDisplayTime[] = L"LatestDisplayTime";
 constexpr wchar_t kRegValueRetentionStudy[] = L"RetentionStudy";
 constexpr wchar_t kRegValueState[] = L"State";
 constexpr wchar_t kRegValueToastCount[] = L"ToastCount";
 constexpr wchar_t kRegValueToastLocation[] = L"ToastLocation";
 constexpr wchar_t kRegValueUserSessionUptime[] = L"UserSessionUptime";
@@ skipping 34 matching lines @@
       install_static::InstallDetails::Get();
 
   if (!system_level) {
     *path = install_details.GetClientStateKeyPath().append(kRegKeyRetention);
     return true;
   }
 
   base::string16 user_sid;
   if (base::win::GetUserSidString(&user_sid)) {
     *path = install_details.GetClientStateMediumKeyPath()
-                .append(L"\\")
                 .append(kRegKeyRetention)
                 .append(L"\\")
                 .append(user_sid);
     return true;
   }
 
   NOTREACHED();
   return false;
 }
 
@@ skipping 46 matching lines @@
 
 }  // namespace
 
 // ExperimentStorage::Lock -----------------------------------------------------
 
 ExperimentStorage::Lock::~Lock() {
   BOOL result = ::ReleaseMutex(storage_->mutex_.Get());
   DCHECK(result);
 }
 
-bool ExperimentStorage::Lock::ReadParticipation(Participation* participation) {
+bool ExperimentStorage::Lock::ReadParticipation(Study* participation) {
   base::win::RegKey key;
   // A failure to open the key likely indicates that this isn't running from a
   // real install of Chrome.
   if (!OpenParticipationKey(false /* !write_access */, &key))
     return false;
 
   DWORD value = 0;
   LONG result = key.ReadValueDW(kRegValueRetentionStudy, &value);
-  if (result != ERROR_SUCCESS) {
-    // This likely means that the value is not present.
-    *participation = Participation::kNotEvaluated;
-  } else if (value == 0) {
-    *participation = Participation::kNotParticipating;
-  } else {
-    *participation = Participation::kIsParticipating;
-  }
+  // An error most likely means that the value is not present.
+  if (result != ERROR_SUCCESS || value == 0)
+    *participation = kNoStudySelected;
+  else if (value == 1)
+    *participation = kStudyOne;
+  else
+    *participation = kStudyTwo;
   return true;
 }
 
-bool ExperimentStorage::Lock::WriteParticipation(Participation participation) {
+bool ExperimentStorage::Lock::WriteParticipation(Study participation) {
+  DCHECK(participation == kNoStudySelected || participation == kStudyOne ||
+         participation == kStudyTwo);
   base::win::RegKey key;
   // A failure to open the key likely indicates that this isn't running from a
   // real install of Chrome.
   if (!OpenParticipationKey(true /* write_access */, &key))
     return false;
 
-  if (participation == Participation::kNotEvaluated)
+  if (participation == kNoStudySelected)
     return key.DeleteValue(kRegValueRetentionStudy) == ERROR_SUCCESS;
-  const DWORD value = participation == Participation::kIsParticipating ? 1 : 0;
-  return key.WriteValue(kRegValueRetentionStudy, value) == ERROR_SUCCESS;
+  return key.WriteValue(kRegValueRetentionStudy, participation) ==
+         ERROR_SUCCESS;
 }
 
 bool ExperimentStorage::Lock::LoadExperiment(Experiment* experiment) {
   // This function loads both the experiment metrics and state from the
   // registry.
   // - If no metrics are found: |experiment| is cleared, and true is returned.
   //   (Per-user experiment data in the registry is ignored for all users.)
   // - If metrics indicate an initial state (prior to a user being elected into
   //   an experiment group): |experiment| is populated with the metrics and true
   //   is returned. (Per-user experiment data in the registry is ignored for all
@@ skipping 265 matching lines @@
   WriteTime(&key, kRegValueLatestDisplayTime,
             experiment.latest_display_time_.ToInternalValue());
   WriteTime(&key, kRegValueUserSessionUptime,
             experiment.user_session_uptime_.ToInternalValue());
   WriteTime(&key, kRegValueActionDelay,
             experiment.action_delay_.ToInternalValue());
   return true;
 }
 
 }  // namespace installer