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 <limits>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.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"
@@ skipping 45 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,
-    int value,
+    size_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);
-  return (key.WriteValue(uniquename.c_str(), value) == ERROR_SUCCESS);
+
+  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);
 }
 
 // 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,
         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::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;
 }