Generalized the storage strategy used by UpdateProfileCounts.

chrome/installer/util/google_update_settings.cc

 // Copyright (c) 2012 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/google_update_settings.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "base/win/registry.h"
 #include "base/win/win_util.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/installer/util/app_registration_data.h"
@@ skipping 41 matching lines @@
   }
   return true;
 }
 
 // Writes |value| into a user-specific value in the key |name| under
 // |app_reg_data|'s ClientStateMedium key in HKLM along with the aggregation
 // method |aggregate|. This function is solely for use by system-level installs.
 bool WriteGoogleUpdateAggregateNumKeyInternal(
     const AppRegistrationData& app_reg_data,
     const wchar_t* const name,
-    size_t value,
+    uint32_t value,
     const wchar_t* const aggregate) {
   DCHECK(aggregate);
   DCHECK(GoogleUpdateSettings::IsSystemInstall());
   const REGSAM kAccess = KEY_SET_VALUE | KEY_WOW64_32KEY;
 
   // Machine installs require each OS user to write a unique key under a
   // named key in HKLM as well as an "aggregation" function that describes
   // how the values of multiple users are to be combined.
   base::string16 uniquename;
   if (!base::win::GetUserSidString(&uniquename)) {
     NOTREACHED();
     return false;
   }
 
   base::string16 reg_path(app_reg_data.GetStateMediumKey());
   reg_path.append(L"\\");
   reg_path.append(name);
   RegKey key(HKEY_LOCAL_MACHINE, reg_path.c_str(), kAccess);
   key.WriteValue(google_update::kRegAggregateMethod, aggregate);
 
-  DWORD dword_value = (value > std::numeric_limits<DWORD>::max() ?
-      std::numeric_limits<DWORD>::max() :
-      static_cast<DWORD>(value));
-  return (key.WriteValue(uniquename.c_str(), dword_value) == ERROR_SUCCESS);
+  return (key.WriteValue(uniquename.c_str(), value) == ERROR_SUCCESS);
 }
 
 // Updates a registry key |name| to be |value| for the given |app_reg_data|.
 bool WriteGoogleUpdateStrKeyInternal(const AppRegistrationData& app_reg_data,
                                      const wchar_t* const name,
                                      const base::string16& value) {
   const REGSAM kAccess = KEY_SET_VALUE | KEY_WOW64_32KEY;
   RegKey key(HKEY_CURRENT_USER, app_reg_data.GetStateKey().c_str(), kAccess);
   return (key.WriteValue(name, value.c_str()) == ERROR_SUCCESS);
 }
 
+// Writes the per-user stat |value_name|=|value| either in ClientStateMedium
+// using summation as the aggregation function or in ClientState directly,
+// depending on whether this is is a per-machine or a per-user install.
+void WritePerUserStat(const AppRegistrationData& app_reg_data,
+                      bool is_system_install,
+                      const wchar_t* value_name,
+                      uint32_t value) {
+  if (is_system_install) {
+    // Write |value| as a DWORD in a per-user value of subkey |value_name|.
+    WriteGoogleUpdateAggregateNumKeyInternal(app_reg_data, value_name, value,
+                                             L"sum()");
+  } else {
+    // Write |value| as a string in value |value_name|.
+    WriteGoogleUpdateStrKeyInternal(app_reg_data, value_name,
+                                    base::UintToString16(value));
+  }
+}
+
 bool WriteGoogleUpdateStrKey(const wchar_t* const name,
                              const base::string16& value) {
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   return WriteGoogleUpdateStrKeyInternal(
       dist->GetAppRegistrationData(), name, value);
 }
 
 bool ClearGoogleUpdateStrKey(const wchar_t* const name) {
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   base::string16 reg_path = dist->GetStateKey();
@@ skipping 483 matching lines @@
     VLOG(1) << "Removed (legacy) stage information; switching to channel: "
             << value->value();
     modified = true;
   }
 
   return modified;
 }
 
 void GoogleUpdateSettings::UpdateProfileCounts(size_t profiles_active,
                                                size_t profiles_signedin) {
-  BrowserDistribution* dist = BrowserDistribution::GetDistribution();
-  // System-level installs must write into the ClientStateMedium key shared by
-  // all users. Special treatment is used to aggregate across those users.
-  if (IsSystemInstall()) {
-    // Write the counts as ints that get aggregated across all users via
-    // summation for system-level installs.
-    WriteGoogleUpdateAggregateNumKeyInternal(
-        dist->GetAppRegistrationData(),
-        google_update::kRegProfilesActive,
-        profiles_active,
-        L"sum()");
-    WriteGoogleUpdateAggregateNumKeyInternal(
-        dist->GetAppRegistrationData(),
-        google_update::kRegProfilesSignedIn,
-        profiles_signedin,
-        L"sum()");
-  } else {
-    // Write the counts as strings since no aggregation function is needed for
-    // user-level installs.
-    WriteGoogleUpdateStrKeyInternal(dist->GetAppRegistrationData(),
-                                    google_update::kRegProfilesActive,
-                                    base::SizeTToString16(profiles_active));
-    WriteGoogleUpdateStrKeyInternal(dist->GetAppRegistrationData(),
-                                    google_update::kRegProfilesSignedIn,
-                                    base::SizeTToString16(profiles_signedin));
-  }
+  const auto& app_reg_data =
+      BrowserDistribution::GetDistribution()->GetAppRegistrationData();
+  const bool is_system_install = IsSystemInstall();
+  WritePerUserStat(app_reg_data, is_system_install,
+                   google_update::kRegProfilesActive,
+                   base::saturated_cast<uint32_t>(profiles_active));
+  WritePerUserStat(app_reg_data, is_system_install,
+                   google_update::kRegProfilesSignedIn,
+                   base::saturated_cast<uint32_t>(profiles_signedin));
 }
 
 int GoogleUpdateSettings::DuplicateGoogleUpdateSystemClientKey() {
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   base::string16 reg_path = dist->GetStateKey();
 
   // Minimum access needed is to be able to write to this key.
   RegKey reg_key(
       HKEY_LOCAL_MACHINE, reg_path.c_str(), KEY_SET_VALUE | KEY_WOW64_32KEY);
   if (!reg_key.Valid())
@@ skipping 401 matching lines @@
   }
 
   // If the key or value was not present, return the empty string.
   if (result == ERROR_FILE_NOT_FOUND || result == ERROR_PATH_NOT_FOUND) {
     experiment_labels->clear();
     return true;
   }
 
   return result == ERROR_SUCCESS;
 }