Profile_Metrics integration with Keystone

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 <algorithm>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 72 matching lines @@
   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);
   return (key.WriteValue(uniquename.c_str(), value) == ERROR_SUCCESS);

[grt (UTC plus 2), 2015/02/24 17:57:00]

presumably this is using the DWORD WriteValue, where DWORD is an unsigned type
(uint32_t, effectively). how about changing |value| in this function from an int
to a size_t and adding a check that the value doesn't exceed the bounds of a
DWORD with something like:

#include <limits>

  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);

this lets you get rid of the unsafe c-style cast in
GoogleUpdateSettings::UpdateProfileCounts.

[Mike Lerman, 2015/02/25 15:00:12]

Ah, great! I didn't realize DWORDs were unsigned. This works perfectly.

 }
 
 // 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);
 }
@@ skipping 435 matching lines @@
 
   if (value->SetMultiFailSuffix(false)) {
     VLOG(1) << "Removed multi-install failure key; switching to channel: "
             << value->value();
     modified = true;
   }
 
   return modified;
 }
 
-void GoogleUpdateSettings::UpdateProfileCounts(int profiles_active,
-                                               int profiles_signedin) {
+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,
+        (int)profiles_active,
         L"sum()");
     WriteGoogleUpdateAggregateNumKeyInternal(
         dist->GetAppRegistrationData(),
         google_update::kRegProfilesSignedIn,
-        profiles_signedin,
+        (int)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::IntToString16(profiles_active));
+                                    base::SizeTToString16(profiles_active));
     WriteGoogleUpdateStrKeyInternal(dist->GetAppRegistrationData(),
                                     google_update::kRegProfilesSignedIn,
-                                    base::IntToString16(profiles_signedin));
+                                    base::SizeTToString16(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);
@@ skipping 372 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;
 }