mac: Prevent Address Book permissions dialog from erroneously appearing.

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 107 matching lines @@
 
 // Called when Keystone registration completes.
 - (void)registrationComplete:(NSNotification*)notification;
 
 // 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:(keystone_glue::AutoupdateStatus)status
+             version:(NSString*)version;
 
 // 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:.
 //
 // In order to check the version on disk, the installed application's
@@ skipping 346 matching lines @@
              preserveTTToken, ksr::KSRegistrationPreserveTrustedTesterTokenKey,
              tagValue, ksr::KSRegistrationTagKey,
              appInfoPlistPath, ksr::KSRegistrationTagPathKey,
              tagKey, ksr::KSRegistrationTagKeyKey,
              brandPath, ksr::KSRegistrationBrandPathKey,
              brandKey, ksr::KSRegistrationBrandKeyKey,
              nil];
 }
 
 - (void)registerWithKeystone {
-  [self updateStatus:kAutoupdateRegistering version:nil];
+  [self updateStatus:keystone_glue::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];
+    [self updateStatus:keystone_glue::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];
 
   // Set up hourly activity pings.
   timer_ = [NSTimer scheduledTimerWithTimeInterval:60 * 60  // One hour
                                             target:self
                                           selector:@selector(markActive:)
                                           userInfo:registration_
                                            repeats:YES];
 }
 
 - (void)registrationComplete:(NSNotification*)notification {
   NSDictionary* userInfo = [notification userInfo];
   if ([[userInfo objectForKey:ksr::KSRegistrationStatusKey] boolValue]) {
     if ([self isSystemTicketDoomed]) {
-      [self updateStatus:kAutoupdateNeedsPromotion version:nil];
+      [self updateStatus:keystone_glue::kAutoupdateNeedsPromotion version:nil];
     } else {
-      [self updateStatus:kAutoupdateRegistered version:nil];
+      [self updateStatus:keystone_glue::kAutoupdateRegistered version:nil];
     }
   } else {
     // Dump registration_?
-    [self updateStatus:kAutoupdateRegisterFailed version:nil];
+    [self updateStatus:keystone_glue::kAutoupdateRegisterFailed version:nil];
   }
 }
 
 - (void)stopTimer {
   [timer_ invalidate];
 }
 
 - (void)markActive:(NSTimer*)timer {
   KSRegistration* ksr = [timer userInfo];
   [ksr setActive];
 }
 
 - (void)checkForUpdate {
   DCHECK(![self asyncOperationPending]);
 
   if (!registration_) {
-    [self updateStatus:kAutoupdateCheckFailed version:nil];
+    [self updateStatus:keystone_glue::kAutoupdateCheckFailed version:nil];
     return;
   }
 
-  [self updateStatus:kAutoupdateChecking version:nil];
+  [self updateStatus:keystone_glue::kAutoupdateChecking version:nil];
 
   [registration_ checkForUpdate];
 
   // Upon completion, ksr::KSRegistrationCheckForUpdateNotification will be
   // posted, and -checkForUpdateComplete: will be called.
 }
 
 - (void)checkForUpdateComplete:(NSNotification*)notification {
   NSDictionary* userInfo = [notification userInfo];
 
   if ([[userInfo objectForKey:ksr::KSRegistrationUpdateCheckErrorKey]
           boolValue]) {
-    [self updateStatus:kAutoupdateCheckFailed version:nil];
+    [self updateStatus:keystone_glue::kAutoupdateCheckFailed version:nil];
   } else if ([[userInfo objectForKey:ksr::KSRegistrationStatusKey] 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];
+    [self updateStatus:keystone_glue::kAutoupdateAvailable version:version];
   } 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]);
 
   if (!registration_) {
-    [self updateStatus:kAutoupdateInstallFailed version:nil];
+    [self updateStatus:keystone_glue::kAutoupdateInstallFailed version:nil];
     return;
   }
 
-  [self updateStatus:kAutoupdateInstalling version:nil];
+  [self updateStatus:keystone_glue::kAutoupdateInstalling version:nil];
 
   [registration_ startUpdate];
 
   // Upon completion, ksr::KSRegistrationStartUpdateNotification will be
   // posted, and -installUpdateComplete: will be called.
 }
 
 - (void)installUpdateComplete:(NSNotification*)notification {
   NSDictionary* userInfo = [notification userInfo];
 
   // 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];
+    [self updateStatus:keystone_glue::kAutoupdateInstallFailed version:nil];
   } 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 {
@@ skipping 18 matching lines @@
 
   [self performSelectorOnMainThread:@selector(determineUpdateStatusForVersion:)
                          withObject:version
                       waitUntilDone:NO];
 }
 
 // Runs on the main thread.
 - (void)determineUpdateStatusForVersion:(NSString*)version {
   DCHECK([NSThread isMainThread]);
 
-  AutoupdateStatus status;
+  keystone_glue::AutoupdateStatus status;
   if (updateSuccessfullyInstalled_) {
     // If an update was successfully installed and this object saw it happen,
     // then don't even bother comparing versions.
-    status = kAutoupdateInstalled;
+    status = keystone_glue::kAutoupdateInstalled;
   } else {
     NSString* currentVersion =
         [NSString stringWithUTF8String:chrome::kChromeVersion];
     if (!version) {
       // If the version on disk could not be determined, assume that
       // whatever's running is current.
       version = currentVersion;
-      status = kAutoupdateCurrent;
+      status = keystone_glue::kAutoupdateCurrent;
     } else if ([version isEqualToString:currentVersion]) {
-      status = kAutoupdateCurrent;
+      status = keystone_glue::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;
+      status = keystone_glue::kAutoupdateInstalled;
     }
   }
 
   [self updateStatus:status version:version];
 }
 
-- (void)updateStatus:(AutoupdateStatus)status version:(NSString*)version {
+- (void)updateStatus:(keystone_glue::AutoupdateStatus)status
+             version:(NSString*)version {
+  DCHECK([NSThread isMainThread]);

[erikchen, 2014/06/12 23:54:41]

I'm not confident that this is true, but the existing code would be pretty
unsafe/broken if this condition wasn't true.

If you prefer, I could redispatch to the main thread if it isn't already there
via gcd instead of having this DCHECK.

   NSNumber* statusNumber = [NSNumber numberWithInt:status];
   NSMutableDictionary* dictionary =
       [NSMutableDictionary dictionaryWithObject:statusNumber
                                          forKey:kAutoupdateStatusStatus];
   if (version) {
     [dictionary setObject:version forKey:kAutoupdateStatusVersion];
   }
 
   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 {
+- (keystone_glue::AutoupdateStatus)recentStatus {
   NSDictionary* dictionary = [recentNotification_ userInfo];
-  return static_cast<AutoupdateStatus>(
+  return static_cast<keystone_glue::AutoupdateStatus>(
       [[dictionary objectForKey:kAutoupdateStatusStatus] intValue]);
 }
 
 - (BOOL)asyncOperationPending {
-  AutoupdateStatus status = [self recentStatus];
-  return status == kAutoupdateRegistering ||
-         status == kAutoupdateChecking ||
-         status == kAutoupdateInstalling ||
-         status == kAutoupdatePromoting;
+  keystone_glue::AutoupdateStatus status = [self recentStatus];
+  return status == keystone_glue::kAutoupdateRegistering ||
+         status == keystone_glue::kAutoupdateChecking ||
+         status == keystone_glue::kAutoupdateInstalling ||
+         status == keystone_glue::kAutoupdatePromoting;
 }
 
 - (BOOL)isUserTicket {
   return [registration_ ticketType] == ksr::kKSRegistrationUserTicket;
 }
 
 - (BOOL)isSystemKeystone {
   struct stat statbuf;
   if (stat("/Library/Google/GoogleSoftwareUpdate/GoogleSoftwareUpdate.bundle/"
            "Contents/MacOS/ksadmin",
@@ skipping 107 matching lines @@
   }
   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:keystone_glue::kAutoupdatePromoting version: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 28 matching lines @@
   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];
+    [self updateStatus:keystone_glue::kAutoupdatePromoteFailed version:nil];
     return;
   }
   if (exit_status != 0) {
     LOG(ERROR) << "keystone_promote_preflight status " << exit_status;
-    [self updateStatus:kAutoupdatePromoteFailed version:nil];
+    [self updateStatus:keystone_glue::kAutoupdatePromoteFailed version:nil];
     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];
+    [self updateStatus:keystone_glue::kAutoupdatePromoteFailed version: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]) {
     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:keystone_glue::kAutoupdatePromoteFailed version: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:keystone_glue::kAutoupdatePromoted version:nil];
 }
 
 - (void)setAppPath:(NSString*)appPath {
   if (appPath != appPath_) {
     [appPath_ release];
     appPath_ = [appPath copy];
   }
 }
 
 - (BOOL)wantsFullInstaller {
@@ skipping 71 matching lines @@
   return [KeystoneGlue defaultKeystoneGlue] != nil;
 }
 
 base::string16 CurrentlyInstalledVersion() {
   KeystoneGlue* keystoneGlue = [KeystoneGlue defaultKeystoneGlue];
   NSString* version = [keystoneGlue currentlyInstalledVersion];
   return base::SysNSStringToUTF16(version);
 }
 
 }  // namespace keystone_glue