Add viewing of error messages from Keystone upon self-update failure.

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>
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/mac/authorization_util.h"
 #include "base/mac/bundle_locations.h"
 #include "base/mac/foundation_util.h"
 #include "base/mac/mac_logging.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/memory/ref_counted.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/threading/worker_pool.h"
 #include "build/build_config.h"
 #import "chrome/browser/mac/keystone_registration.h"
 #include "chrome/common/channel_info.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/version_info/version_info.h"
 #include "ui/base/l10n/l10n_util.h"
@@ skipping 88 matching lines @@
 
 // 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;
+- (void)updateStatus:(AutoupdateStatus)status
+             version:(NSString*)version
+               error:(NSString*)error;
 
 // Returns the version of the currently-installed application on disk.
 - (NSString*)currentlyInstalledVersion;
 
 // These three methods are used to determine the version of the application
 // currently installed on disk, compare that to the currently-running version,
 // decide whether any updates have been installed, and call
-// -updateStatus:version:.
+// -updateStatus:version:error:.
 //
 // In order to check the version on disk, the installed application's
 // Info.plist dictionary must be read; in order to see changes as updates are
 // applied, the dictionary must be read each time, bypassing any caches such
 // as the one that NSBundle might be maintaining.  Reading files can be a
 // blocking operation, and blocking operations are to be avoided on the main
 // thread.  I'm not quite sure what jank means, but I bet that a blocked main
 // thread would cause some of it.
 //
 // -determineUpdateStatusAsync is called on the main thread to initiate the
 // operation.  It performs initial set-up work that must be done on the main
 // thread and arranges for -determineUpdateStatus to be called on a work queue
 // thread managed by WorkerPool.
 // -determineUpdateStatus then reads the Info.plist, gets the version from the
 // CFBundleShortVersionString key, and performs
 // -determineUpdateStatusForVersion: on the main thread.
 // -determineUpdateStatusForVersion: does the actual comparison of the version
-// on disk with the running version and calls -updateStatus:version: with the
-// results of its analysis.
+// on disk with the running version and calls -updateStatus:version:error: with
+// the results of its analysis.
 - (void)determineUpdateStatusAsync;
 - (void)determineUpdateStatus;
 - (void)determineUpdateStatusForVersion:(NSString*)version;
 
 // Returns YES if registration_ is definitely on a user ticket.  If definitely
 // on a system ticket, or uncertain of ticket type (due to an older version
 // of Keystone being used), returns NO.
 - (BOOL)isUserTicket;
 
 // Returns YES if Keystone is definitely installed at the system level,
@@ skipping 33 matching lines @@
 // tag key.  If a full installer (as opposed to a binary diff/delta patch) is
 // required, the tag suffix will contain the string "-full". If no special
 // treatment is required, the tag suffix will be an empty string.
 - (NSString*)tagSuffix;
 
 @end  // @interface KeystoneGlue (Private)
 
 NSString* const kAutoupdateStatusNotification = @"AutoupdateStatusNotification";
 NSString* const kAutoupdateStatusStatus = @"status";
 NSString* const kAutoupdateStatusVersion = @"version";
+NSString* const kAutoupdateStatusErrorMessages = @"errormessages";
 
 namespace {
 
 NSString* const kChannelKey = @"KSChannelID";
 NSString* const kBrandKey = @"KSBrandID";
 NSString* const kVersionKey = @"KSVersion";
 
 }  // namespace
 
 @implementation KeystoneGlue
@@ skipping 61 matching lines @@
   // what's significant here: it's used to locate the outermost part of the
   // application for the existence checker and other operations that need to
   // see the entire application bundle.
   return [base::mac::OuterBundle() infoDictionary];
 }
 
 - (void)loadParameters {
   NSBundle* appBundle = base::mac::OuterBundle();
   NSDictionary* infoDictionary = [self infoDictionary];
 
-  NSString* productID = [infoDictionary objectForKey:@"KSProductID"];
+  NSString* productID = base::mac::ObjCCast<NSString>(
+      [infoDictionary objectForKey:@"KSProductID"]);
   if (productID == nil) {
     productID = [appBundle bundleIdentifier];
   }
 
   NSString* appPath = [appBundle bundlePath];
-  NSString* url = [infoDictionary objectForKey:@"KSUpdateURL"];
-  NSString* version = [infoDictionary objectForKey:kVersionKey];
+  NSString* url = base::mac::ObjCCast<NSString>(
+      [infoDictionary objectForKey:@"KSUpdateURL"]);
+  NSString* version = base::mac::ObjCCast<NSString>(
+      [infoDictionary objectForKey:kVersionKey]);
 
   if (!productID || !appPath || !url || !version) {
     // If parameters required for Keystone are missing, don't use it.
     return;
   }
 
-  NSString* channel = [infoDictionary objectForKey:kChannelKey];
+  NSString* channel = base::mac::ObjCCast<NSString>(
+      [infoDictionary objectForKey:kChannelKey]);
   // The stable channel has no tag.  If updating to stable, remove the
   // dev and beta tags since we've been "promoted".
   if (channel == nil)
     channel = ksr::KSRegistrationRemoveExistingTag;
 
   productID_ = [productID retain];
   appPath_ = [appPath retain];
   url_ = [url retain];
   version_ = [version retain];
   channel_ = [channel retain];
@@ skipping 41 matching lines @@
 
         // Clean up any old user level file.
         if ([fm fileExistsAtPath:userBrandFile]) {
           [fm removeItemAtPath:userBrandFile error:NULL];
         }
 
       } else {
         // User
 
         NSDictionary* infoDictionary = [self infoDictionary];
-        NSString* appBundleBrandID = [infoDictionary objectForKey:kBrandKey];
+        NSString* appBundleBrandID = base::mac::ObjCCast<NSString>(
+            [infoDictionary objectForKey:kBrandKey]);
 
         NSString* storedBrandID = nil;
         if ([fm fileExistsAtPath:userBrandFile]) {
           NSDictionary* storedBrandDict =
               [NSDictionary dictionaryWithContentsOfFile:userBrandFile];
-          storedBrandID = [storedBrandDict objectForKey:kBrandKey];
+          storedBrandID = base::mac::ObjCCast<NSString>(
+              [storedBrandDict objectForKey:kBrandKey]);
         }
 
         if ((appBundleBrandID != nil) &&
             (![storedBrandID isEqualTo:appBundleBrandID])) {
           // App and store don't match, update store and use it.
           NSDictionary* storedBrandDict =
               [NSDictionary dictionaryWithObject:appBundleBrandID
                                           forKey:kBrandKey];
           // If Keystone hasn't been installed yet, the location the brand file
           // is written to won't exist, so manually create the directory.
@@ skipping 102 matching lines @@
              preserveTTToken, ksr::KSRegistrationPreserveTrustedTesterTokenKey,
              tagValue, ksr::KSRegistrationTagKey,
              appInfoPlistPath, ksr::KSRegistrationTagPathKey,
              tagKey, ksr::KSRegistrationTagKeyKey,
              brandPath, ksr::KSRegistrationBrandPathKey,
              brandKey, ksr::KSRegistrationBrandKeyKey,
              nil];
 }
 
 - (void)setRegistrationActive {
-  if (!registration_)
-    return;
+  DCHECK(registration_);
+
   registrationActive_ = YES;
 
   // Should never have zero profiles. Do not report this value.
   if (!numProfiles_) {
     [registration_ setActive];
     return;
   }
 
   NSError* reportingError = nil;
 
@@ skipping 20 matching lines @@
   NSArray* profileCountsInformation =
       [NSArray arrayWithObjects:numAccountsAttr, numSignedInAccountsAttr, nil];
 
   if (![registration_ setActiveWithReportingAttributes:profileCountsInformation
                                                  error:&reportingError]) {
     VLOG(1) << [reportingError localizedDescription];
   }
 }
 
 - (void)registerWithKeystone {
-  [self updateStatus:kAutoupdateRegistering version:nil];
+  DCHECK(registration_);
+
+  [self updateStatus:kAutoupdateRegistering version:nil error:nil];
 
   NSDictionary* parameters = [self keystoneParameters];
   BOOL result = [registration_ registerWithParameters:parameters];
   if (!result) {
-    [self updateStatus:kAutoupdateRegisterFailed version:nil];
+    // TODO: If Keystone ever makes a variant of this API with a withError:
+    // parameter, include the error message here in the call to updateStatus:.
+    [self updateStatus:kAutoupdateRegisterFailed version:nil error:nil];
     return;
   }
 
   // Upon completion, ksr::KSRegistrationDidCompleteNotification will be
   // posted, and -registrationComplete: will be called.
 
   // Set up hourly activity pings.
   timer_ = [NSTimer scheduledTimerWithTimeInterval:60 * 60  // One hour
                                             target:self
                                           selector:@selector(markActive:)
                                           userInfo:nil
                                            repeats:YES];
 }
 
 - (BOOL)isRegisteredAndActive {
   return registrationActive_;
 }
 
 - (void)registrationComplete:(NSNotification*)notification {
   NSDictionary* userInfo = [notification userInfo];
-  if ([[userInfo objectForKey:ksr::KSRegistrationStatusKey] boolValue]) {
+  NSNumber* status = base::mac::ObjCCast<NSNumber>(
+     [userInfo objectForKey:ksr::KSRegistrationStatusKey]);
+  NSString* errorMessages = base::mac::ObjCCast<NSString>(
+     [userInfo objectForKey:ksr::KSRegistrationUpdateCheckRawErrorMessagesKey]);
+
+  if ([status boolValue]) {
     if ([self isSystemTicketDoomed]) {
-      [self updateStatus:kAutoupdateNeedsPromotion version:nil];
+      [self updateStatus:kAutoupdateNeedsPromotion
+                 version:nil
+                   error:errorMessages];
     } else {
-      [self updateStatus:kAutoupdateRegistered version:nil];
+      [self updateStatus:kAutoupdateRegistered
+                 version:nil
+                   error:errorMessages];
     }
   } else {
     // Dump registration_?
-    [self updateStatus:kAutoupdateRegisterFailed version:nil];
+    [self updateStatus:kAutoupdateRegisterFailed
+               version:nil
+                 error:errorMessages];
   }
 }
 
 - (void)stopTimer {
   [timer_ invalidate];
 }
 
 - (void)markActive:(NSTimer*)timer {
   [self setRegistrationActive];
 }
 
 - (void)checkForUpdate {
-  DCHECK(![self asyncOperationPending]);
+  DCHECK(registration_);
 
-  if (!registration_) {
-    [self updateStatus:kAutoupdateCheckFailed version:nil];
+  if ([self asyncOperationPending]) {
+    // Update check already in process; return without doing anything.
     return;
   }
 
-  [self updateStatus:kAutoupdateChecking version:nil];
+  [self updateStatus:kAutoupdateChecking version:nil error:nil];
 
   // All checks from inside Chrome are considered user-initiated, because they
   // only happen following a user action, such as visiting the about page.
   // Non-user-initiated checks are the periodic checks automatically made by
   // Keystone, which don't come through this code path (or even this process).
   [registration_ checkForUpdateWasUserInitiated:YES];
 
   // Upon completion, ksr::KSRegistrationCheckForUpdateNotification will be
   // posted, and -checkForUpdateComplete: will be called.
 }
 
 - (void)checkForUpdateComplete:(NSNotification*)notification {
   NSDictionary* userInfo = [notification userInfo];
+  NSNumber* error = base::mac::ObjCCast<NSNumber>(
+      [userInfo objectForKey:ksr::KSRegistrationUpdateCheckErrorKey]);
+  NSNumber* status = base::mac::ObjCCast<NSNumber>(
+      [userInfo objectForKey:ksr::KSRegistrationStatusKey]);
+  NSString* errorMessages = base::mac::ObjCCast<NSString>(
+     [userInfo objectForKey:ksr::KSRegistrationUpdateCheckRawErrorMessagesKey]);
 
-  if ([[userInfo objectForKey:ksr::KSRegistrationUpdateCheckErrorKey]
-          boolValue]) {
-    [self updateStatus:kAutoupdateCheckFailed version:nil];
-  } else if ([[userInfo objectForKey:ksr::KSRegistrationStatusKey] boolValue]) {
+  if ([error boolValue]) {
+    [self updateStatus:kAutoupdateCheckFailed
+               version:nil
+                 error:errorMessages];
+  } else if ([status boolValue]) {
     // If an update is known to be available, go straight to
     // -updateStatus:version:.  It doesn't matter what's currently on disk.
-    NSString* version = [userInfo objectForKey:ksr::KSRegistrationVersionKey];
-    [self updateStatus:kAutoupdateAvailable version:version];
+    NSString* version = base::mac::ObjCCast<NSString>(
+        [userInfo objectForKey:ksr::KSRegistrationVersionKey]);
+    [self updateStatus:kAutoupdateAvailable
+               version:version
+                 error:errorMessages];
   } else {
     // If no updates are available, check what's on disk, because an update
     // may have already been installed.  This check happens on another thread,
     // and -updateStatus:version: will be called on the main thread when done.
     [self determineUpdateStatusAsync];
   }
 }
 
 - (void)installUpdate {
-  DCHECK(![self asyncOperationPending]);
+  DCHECK(registration_);
 
-  if (!registration_) {
-    [self updateStatus:kAutoupdateInstallFailed version:nil];
+  if ([self asyncOperationPending]) {
+    // Update check already in process; return without doing anything.
     return;
   }
 
-  [self updateStatus:kAutoupdateInstalling version:nil];
+  [self updateStatus:kAutoupdateInstalling version:nil error:nil];
 
   [registration_ startUpdate];
 
   // Upon completion, ksr::KSRegistrationStartUpdateNotification will be
   // posted, and -installUpdateComplete: will be called.
 }
 
 - (void)installUpdateComplete:(NSNotification*)notification {
   NSDictionary* userInfo = [notification userInfo];
+  NSNumber* successfulInstall = base::mac::ObjCCast<NSNumber>(
+      [userInfo objectForKey:ksr::KSUpdateCheckSuccessfullyInstalledKey]);
+  NSString* errorMessages = base::mac::ObjCCast<NSString>(
+     [userInfo objectForKey:ksr::KSRegistrationUpdateCheckRawErrorMessagesKey]);
 
   // http://crbug.com/160308 and b/7517358: when using system Keystone and on
   // a user ticket, KSUpdateCheckSuccessfulKey will be NO even when an update
   // was installed correctly, so don't check it. It should be redudnant when
   // KSUpdateCheckSuccessfullyInstalledKey is checked.
-  if (![[userInfo objectForKey:ksr::KSUpdateCheckSuccessfullyInstalledKey]
-          intValue]) {
-    [self updateStatus:kAutoupdateInstallFailed version:nil];
+  if (![successfulInstall intValue]) {
+    [self updateStatus:kAutoupdateInstallFailed
+               version:nil
+                 error:errorMessages];
   } else {
     updateSuccessfullyInstalled_ = YES;
 
     // Nothing in the notification dictionary reports the version that was
     // installed.  Figure it out based on what's on disk.
     [self determineUpdateStatusAsync];
   }
 }
 
 - (NSString*)currentlyInstalledVersion {
   NSString* appInfoPlistPath = [self appInfoPlistPath];
   NSDictionary* infoPlist =
       [NSDictionary dictionaryWithContentsOfFile:appInfoPlistPath];
-  return [infoPlist objectForKey:@"CFBundleShortVersionString"];
+  return base::mac::ObjCCast<NSString>(
+      [infoPlist objectForKey:@"CFBundleShortVersionString"]);
 }
 
 // Runs on the main thread.
 - (void)determineUpdateStatusAsync {
   DCHECK([NSThread isMainThread]);
 
   PerformBridge::PostPerform(self, @selector(determineUpdateStatus));
 }
 
 // Runs on a thread managed by WorkerPool.
@@ skipping 28 matching lines @@
       status = kAutoupdateCurrent;
     } else {
       // If the version on disk doesn't match what's currently running, an
       // update must have been applied in the background, without this app's
       // direct participation.  Leave updateSuccessfullyInstalled_ alone
       // because there's no direct knowledge of what actually happened.
       status = kAutoupdateInstalled;
     }
   }
 
-  [self updateStatus:status version:version];
+  [self updateStatus:status version:version error:nil];
 }
 
-- (void)updateStatus:(AutoupdateStatus)status version:(NSString*)version {
+- (void)updateStatus:(AutoupdateStatus)status
+             version:(NSString*)version
+               error:(NSString*)error {
   NSNumber* statusNumber = [NSNumber numberWithInt:status];
   NSMutableDictionary* dictionary =
       [NSMutableDictionary dictionaryWithObject:statusNumber
                                          forKey:kAutoupdateStatusStatus];
   if (version) {
     [dictionary setObject:version forKey:kAutoupdateStatusVersion];
   }
+  if (error) {
+    [dictionary setObject:version forKey:kAutoupdateStatusErrorMessages];
+  }
 
   NSNotification* notification =
       [NSNotification notificationWithName:kAutoupdateStatusNotification
                                     object:self
                                   userInfo:dictionary];
   recentNotification_.reset([notification retain]);
 
   [[NSNotificationCenter defaultCenter] postNotification:notification];
 }
 
 - (NSNotification*)recentNotification {
   return [[recentNotification_ retain] autorelease];
 }
 
 - (AutoupdateStatus)recentStatus {
   NSDictionary* dictionary = [recentNotification_ userInfo];
-  return static_cast<AutoupdateStatus>(
-      [[dictionary objectForKey:kAutoupdateStatusStatus] intValue]);
+  NSNumber* status = base::mac::ObjCCastStrict<NSNumber>(
+      [dictionary objectForKey:kAutoupdateStatusStatus]);
+  return static_cast<AutoupdateStatus>([status intValue]);
 }
 
 - (BOOL)asyncOperationPending {
   AutoupdateStatus status = [self recentStatus];
   return status == kAutoupdateRegistering ||
          status == kAutoupdateChecking ||
          status == kAutoupdateInstalling ||
          status == kAutoupdatePromoting;
 }
 
 - (BOOL)isUserTicket {
+  DCHECK(registration_);
   return [registration_ ticketType] == ksr::kKSRegistrationUserTicket;
 }
 
 - (BOOL)isSystemKeystone {
   struct stat statbuf;
   if (stat("/Library/Google/GoogleSoftwareUpdate/GoogleSoftwareUpdate.bundle/"
            "Contents/MacOS/ksadmin",
            &statbuf) != 0) {
     return NO;
   }
@@ skipping 87 matching lines @@
           base::mac::NSToCFCast(prompt)));
   if (!authorization.get()) {
     return;
   }
 
   [self promoteTicketWithAuthorization:authorization.release() synchronous:NO];
 }
 
 - (void)promoteTicketWithAuthorization:(AuthorizationRef)authorization_arg
                            synchronous:(BOOL)synchronous {
+  DCHECK(registration_);
+
   base::mac::ScopedAuthorizationRef authorization(authorization_arg);
   authorization_arg = NULL;
 
   if ([self asyncOperationPending]) {
     // Starting a synchronous operation while an asynchronous one is pending
     // could be trouble.
     return;
   }
   if (!synchronous && ![self wantsPromotion]) {
     // If operating synchronously, the call came from the installer, which
     // means that a system ticket is required.  Otherwise, only allow
     // promotion if it's wanted.
     return;
   }
 
   synchronousPromotion_ = synchronous;
 
-  [self updateStatus:kAutoupdatePromoting version:nil];
+  [self updateStatus:kAutoupdatePromoting version:nil error:nil];
 
   // TODO(mark): Remove when able!
   //
   // keystone_promote_preflight will copy the current brand information out to
   // the system level so all users can share the data as part of the ticket
   // promotion.
   //
   // It will also ensure that the Keystone system ticket store is in a usable
   // state for all users on the system.  Ideally, Keystone's installer or
   // another part of Keystone would handle this.  The underlying problem is
@@ skipping 26 matching lines @@
 
   int exit_status;
   OSStatus status = base::mac::ExecuteWithPrivilegesAndWait(
       authorization,
       preflightPathC,
       kAuthorizationFlagDefaults,
       arguments,
       NULL,  // pipe
       &exit_status);
   if (status != errAuthorizationSuccess) {
-    OSSTATUS_LOG(ERROR, status)
-        << "AuthorizationExecuteWithPrivileges preflight";
-    [self updateStatus:kAutoupdatePromoteFailed version:nil];
+    // It's possible to get an OS-provided error string for this return code
+    // using base::mac::DescriptionFromOSStatus, but most of those strings are
+    // not useful/actionable for users, so we stick with the error code instead.
+    NSString* errorMessage =
+        l10n_util::GetNSStringFWithFixup(IDS_PROMOTE_PREFLIGHT_LAUNCH_ERROR,
+                                         base::IntToString16(status));
+    [self updateStatus:kAutoupdatePromoteFailed
+               version:nil
+                 error:errorMessage];
     return;
   }
   if (exit_status != 0) {
-    LOG(ERROR) << "keystone_promote_preflight status " << exit_status;
-    [self updateStatus:kAutoupdatePromoteFailed version:nil];
+    NSString* errorMessage =
+        l10n_util::GetNSStringFWithFixup(IDS_PROMOTE_PREFLIGHT_SCRIPT_ERROR,
+                                         base::IntToString16(status));
+    [self updateStatus:kAutoupdatePromoteFailed
+               version:nil
+                 error:errorMessage];
     return;
   }
 
   // Hang on to the AuthorizationRef so that it can be used once promotion is
   // complete.  Do this before asking Keystone to promote the ticket, because
   // -promotionComplete: may be called from inside the Keystone promotion
   // call.
   authorization_.swap(authorization);
 
   NSDictionary* parameters = [self keystoneParameters];
 
   // If the brand file is user level, update parameters to point to the new
   // system level file during promotion.
   if (brandFileType_ == kBrandFileTypeUser) {
     NSMutableDictionary* temp_parameters =
         [[parameters mutableCopy] autorelease];
     [temp_parameters setObject:SystemBrandFilePath()
                         forKey:ksr::KSRegistrationBrandPathKey];
     parameters = temp_parameters;
   }
 
   if (![registration_ promoteWithParameters:parameters
                               authorization:authorization_]) {
-    [self updateStatus:kAutoupdatePromoteFailed version:nil];
+    // TODO: If Keystone ever makes a variant of this API with a withError:
+    // parameter, include the error message here in the call to updateStatus:.
+    [self updateStatus:kAutoupdatePromoteFailed version:nil error:nil];
     authorization_.reset();
     return;
   }
 
   // Upon completion, ksr::KSRegistrationPromotionDidCompleteNotification will
   // be posted, and -promotionComplete: will be called.
 
   // If synchronous, see to it that this happens immediately. Give it a
   // 10-second deadline.
   if (synchronous) {
     CFRunLoopRunInMode(kCFRunLoopDefaultMode, 10, false);
   }
 }
 
 - (void)promotionComplete:(NSNotification*)notification {
   NSDictionary* userInfo = [notification userInfo];
-  if ([[userInfo objectForKey:ksr::KSRegistrationStatusKey] boolValue]) {
+  NSNumber* status = base::mac::ObjCCast<NSNumber>(
+      [userInfo objectForKey:ksr::KSRegistrationStatusKey]);
+
+  if ([status boolValue]) {
     if (synchronousPromotion_) {
       // Short-circuit: if performing a synchronous promotion, the promotion
       // came from the installer, which already set the permissions properly.
       // Rather than run a duplicate permission-changing operation, jump
       // straight to "done."
       [self changePermissionsForPromotionComplete];
     } else {
       [self changePermissionsForPromotionAsync];
     }
   } else {
     authorization_.reset();
-    [self updateStatus:kAutoupdatePromoteFailed version:nil];
+    [self updateStatus:kAutoupdatePromoteFailed version:nil error:nil];
   }
 
   if (synchronousPromotion_) {
     // The run loop doesn't need to wait for this any longer.
     CFRunLoopRef runLoop = CFRunLoopGetCurrent();
     CFRunLoopStop(runLoop);
     CFRunLoopWakeUp(runLoop);
   }
 }
 
@@ skipping 35 matching lines @@
 
   SEL selector = @selector(changePermissionsForPromotionComplete);
   [self performSelectorOnMainThread:selector
                          withObject:nil
                       waitUntilDone:NO];
 }
 
 - (void)changePermissionsForPromotionComplete {
   authorization_.reset();
 
-  [self updateStatus:kAutoupdatePromoted version:nil];
+  [self updateStatus:kAutoupdatePromoted version:nil error:nil];
 }
 
 - (void)setAppPath:(NSString*)appPath {
   if (appPath != appPath_) {
     [appPath_ release];
     appPath_ = [appPath copy];
   }
 }
 
 - (BOOL)wantsFullInstaller {
@@ skipping 81 matching lines @@
   return [KeystoneGlue defaultKeystoneGlue] != nil;
 }
 
 base::string16 CurrentlyInstalledVersion() {
   KeystoneGlue* keystoneGlue = [KeystoneGlue defaultKeystoneGlue];
   NSString* version = [keystoneGlue currentlyInstalledVersion];
   return base::SysNSStringToUTF16(version);
 }
 
 }  // namespace keystone_glue