Profile_Metrics integration with Keystone

chrome/browser/mac/keystone_glue.mm

 // 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.
 
 #import "chrome/browser/mac/keystone_glue.h"
 
 #include <sys/mount.h>
 #include <sys/param.h>
 #include <sys/stat.h>
 
@@ skipping 101 matching lines @@
 // outer application bundle's Info.plist, not the framework's Info.plist.
 - (NSString*)appInfoPlistPath;
 
 // Returns a dictionary containing parameters to be used for a KSRegistration
 // -registerWithParameters: or -promoteWithParameters:authorization: call.
 - (NSDictionary*)keystoneParameters;
 
 // Called when Keystone registration completes.
 - (void)registrationComplete:(NSNotification*)notification;
 
+// Set the registration active and pass profile count parameters.
+- (void)setRegistrationActive;
+
 // Called periodically to announce activity by pinging the Keystone server.
 - (void)markActive:(NSTimer*)timer;
 
 // Called when an update check or update installation is complete.  Posts the
 // kAutoupdateStatusNotification notification to the default notification
 // center.
 - (void)updateStatus:(AutoupdateStatus)status version:(NSString*)version;
 
 // Returns the version of the currently-installed application on disk.
 - (NSString*)currentlyInstalledVersion;
@@ skipping 306 matching lines @@
   NSBundle* ksrBundle = [NSBundle bundleWithPath:ksrPath];
   [ksrBundle load];
 
   // Harness the KSRegistration class.
   Class ksrClass = [ksrBundle classNamed:@"KSRegistration"];
   KSRegistration* ksr = [ksrClass registrationWithProductID:productID_];
   if (!ksr)
     return NO;
 
   registration_ = [ksr retain];
+  ksUnsignedReportingAttributeClass_ =
+      [ksrBundle classNamed:@"KSUnsignedReportingAttribute"];
   return YES;
 }
 
 - (NSString*)appInfoPlistPath {
   // NSBundle ought to have a way to access this path directly, but it
   // doesn't.
   return [[appPath_ stringByAppendingPathComponent:@"Contents"]
              stringByAppendingPathComponent:@"Info.plist"];
 }
 
@@ skipping 26 matching lines @@
              url_, ksr::KSRegistrationServerURLStringKey,
              preserveTTToken, ksr::KSRegistrationPreserveTrustedTesterTokenKey,
              tagValue, ksr::KSRegistrationTagKey,
              appInfoPlistPath, ksr::KSRegistrationTagPathKey,
              tagKey, ksr::KSRegistrationTagKeyKey,
              brandPath, ksr::KSRegistrationBrandPathKey,
              brandKey, ksr::KSRegistrationBrandKeyKey,
              nil];
 }
 
+- (void)setRegistrationActive {
+  if (!registration_)
+    return;
+
+  // Should never have zero profiles. Do not report this value.
+  if (!numProfiles_) {
+    [registration_ setActive];
+    return;
+  }
+
+  NSError* reportingError = nil;
+
+  KSReportingAttribute* numAccountsAttr =
+      [ksUnsignedReportingAttributeClass_
+          reportingAttributeWithValue:numProfiles_
+                                 name:@"_NumAccounts"
+                      aggregationType:kKSReportingAggregationSum
+                                error:&reportingError];
+  if (reportingError != nil)
+    VLOG(1) << [reportingError localizedDescription];
+  reportingError = nil;
+
+  KSReportingAttribute* numSignedInAccountsAttr =
+      [ksUnsignedReportingAttributeClass_
+          reportingAttributeWithValue:numSignedInProfiles_
+                                 name:@"_NumSignedIn"
+                      aggregationType:kKSReportingAggregationSum
+                                error:&reportingError];
+  if (reportingError != nil)
+    VLOG(1) << [reportingError localizedDescription];
+  reportingError = nil;
+
+  NSArray* profileCountsInformation =
+      [NSArray arrayWithObjects:numAccountsAttr, numSignedInAccountsAttr, nil];
+
+  if (![registration_ setActiveWithReportingAttributes:profileCountsInformation
+                                                 error:&reportingError]) {
+    VLOG(1) << [reportingError localizedDescription];
+  }
+}
+
 - (void)registerWithKeystone {
   [self updateStatus:kAutoupdateRegistering version:nil];
 
   NSDictionary* parameters = [self keystoneParameters];
   BOOL result;
   {
     // TODO(shess): Allows Keystone to throw an exception when
     // /usr/bin/python does not exist (really!).
     // http://crbug.com/86221 and http://crbug.com/87931
     base::mac::ScopedNSExceptionEnabler enabler;
     result = [registration_ registerWithParameters:parameters];
   }
   if (!result) {
     [self updateStatus:kAutoupdateRegisterFailed version:nil];
     return;
   }
 
   // Upon completion, ksr::KSRegistrationDidCompleteNotification will be
   // posted, and -registrationComplete: will be called.
 
   // Mark an active RIGHT NOW; don't wait an hour for the first one.
-  [registration_ setActive];
+  [self setRegistrationActive];
 
   // Set up hourly activity pings.
   timer_ = [NSTimer scheduledTimerWithTimeInterval:60 * 60  // One hour
                                             target:self
                                           selector:@selector(markActive:)
-                                          userInfo:registration_
+                                          userInfo:nil
                                            repeats:YES];
 }
 
 - (void)registrationComplete:(NSNotification*)notification {
   NSDictionary* userInfo = [notification userInfo];
   if ([[userInfo objectForKey:ksr::KSRegistrationStatusKey] boolValue]) {
     if ([self isSystemTicketDoomed]) {
       [self updateStatus:kAutoupdateNeedsPromotion version:nil];
     } else {
       [self updateStatus:kAutoupdateRegistered version:nil];
     }
   } else {
     // Dump registration_?
     [self updateStatus:kAutoupdateRegisterFailed version:nil];
   }
 }
 
 - (void)stopTimer {
   [timer_ invalidate];
 }
 
 - (void)markActive:(NSTimer*)timer {
-  KSRegistration* ksr = [timer userInfo];
-  [ksr setActive];
+  [self setRegistrationActive];
 }
 
 - (void)checkForUpdate {
   DCHECK(![self asyncOperationPending]);
 
   if (!registration_) {
     [self updateStatus:kAutoupdateCheckFailed version:nil];
     return;
   }
 
@@ skipping 486 matching lines @@
   NSString* tagSuffix = @"";
   if (ObsoleteSystemMac::Has32BitOnlyCPU()) {
     tagSuffix = [tagSuffix stringByAppendingString:@"-32bit"];
   }
   if ([self wantsFullInstaller]) {
     tagSuffix = [tagSuffix stringByAppendingString:@"-full"];
   }
   return tagSuffix;
 }
 
+
+- (void)updateProfileCountsWithNumProfiles:(uint32_t)profiles
+                       numSignedInProfiles:(uint32_t)signedInProfiles {
+  numProfiles_ = profiles;
+  numSignedInProfiles_ = signedInProfiles;
+}
+
 @end  // @implementation KeystoneGlue
 
 namespace {
 
 std::string BrandCodeInternal() {
   KeystoneGlue* keystone_glue = [KeystoneGlue defaultKeystoneGlue];
   NSString* brand_path = [keystone_glue brandFilePath];
 
   if (![brand_path length])
     return std::string();
@@ skipping 22 matching lines @@
   return [KeystoneGlue defaultKeystoneGlue] != nil;
 }
 
 base::string16 CurrentlyInstalledVersion() {
   KeystoneGlue* keystoneGlue = [KeystoneGlue defaultKeystoneGlue];
   NSString* version = [keystoneGlue currentlyInstalledVersion];
   return base::SysNSStringToUTF16(version);
 }
 
 }  // namespace keystone_glue