Don't directly link to the private Xcode framework, instead find it at runtime

testing/iossim/iossim.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 <Foundation/Foundation.h>
 #include <asl.h>
 #include <libgen.h>
 #include <stdarg.h>
 #include <stdio.h>
 
@@ skipping 52 matching lines @@
 // If this timeout occurs iossim will likely exit with non-zero status; the
 // exception being if the app is invoked and completes execution before the
 // session is started (this case is handled in session:didStart:withError).
 const NSTimeInterval kSessionStartTimeoutSeconds = 30;
 
 // While the simulated app is running, its stdout is redirected to a file which
 // is polled by iossim and written to iossim's stdout using the following
 // polling interval.
 const NSTimeInterval kOutputPollIntervalSeconds = 0.1;
 
+// The path within the developer dir of the private Simulator frameworks.
+NSString* const kSimulatorFrameworkRelativePath =
+    @"Platforms/iPhoneSimulator.platform/Developer/Library/PrivateFrameworks/"
+    @"iPhoneSimulatorRemoteClient.framework";
+NSString* const kDevToolsFoundationRelativePath =
+    @"../OtherFrameworks/DevToolsFoundation.framework";
+
 const char* gToolName = "iossim";
 
 void LogError(NSString* format, ...) {
   va_list list;
   va_start(list, format);
 
   NSString* message =
       [[[NSString alloc] initWithFormat:format arguments:list] autorelease];
 
   fprintf(stderr, "%s: ERROR: %s\n", gToolName, [message UTF8String]);
@@ skipping 158 matching lines @@
   if (entryFound) {
     LogError(@"Simulated app crashed or exited with non-zero status");
     exit(EXIT_FAILURE);
   }
   exit(EXIT_SUCCESS);
 }
 @end
 
 namespace {
 
+// Finds the developer dir via xcode-select or the DEVELOPER_DIR environment
+// variable.
+NSString* FindDeveloperDir() {
+  // Check the env first.
+  NSDictionary* env = [[NSProcessInfo processInfo] environment];
+  NSString* developerDir = [env objectForKey:@"DEVELOPER_DIR"];
+  if ([developerDir length] > 0)
+    return developerDir;
+
+  // Go look for it via xcode-select.
+  NSTask* xcodeSelectTask = [[[NSTask alloc] init] autorelease];
+  [xcodeSelectTask setLaunchPath:@"/usr/bin/xcode-select"];
+  [xcodeSelectTask setArguments:[NSArray arrayWithObject:@"-print-path"]];
+
+  NSPipe* outputPipe = [NSPipe pipe];
+  [xcodeSelectTask setStandardOutput:outputPipe];
+  NSFileHandle* outputFile = [outputPipe fileHandleForReading];
+
+  [xcodeSelectTask launch];
+  NSData* outputData = [outputFile readDataToEndOfFile];
+  [xcodeSelectTask terminate];
+
+  NSString* output =
+      [[[NSString alloc] initWithData:outputData
+                             encoding:NSUTF8StringEncoding] autorelease];
+  output = [output stringByTrimmingCharactersInSet:
+      [NSCharacterSet whitespaceAndNewlineCharacterSet]];
+  if ([output length] == 0)
+    output = nil;
+  return output;
+}
+
+// Loads the Simulator framework from the given developer dir.
+NSBundle* LoadSimulatorFramework(NSString* developerDir) {
+  // The Simulator framework depends on some of the other Xcode private
+  // frameworks; manually load them first so everything can be linked up.
+  NSString* devToolsFoundationPath = [developerDir
+      stringByAppendingPathComponent:kDevToolsFoundationRelativePath];
+  NSBundle* devToolsFoundationBundle =
+      [NSBundle bundleWithPath:devToolsFoundationPath];
+  if (![devToolsFoundationBundle load])
+    return nil;
+  NSString* simBundlePath = [developerDir
+      stringByAppendingPathComponent:kSimulatorFrameworkRelativePath];
+  NSBundle* simBundle = [NSBundle bundleWithPath:simBundlePath];
+  if (![simBundle load])
+    return nil;
+  return simBundle;
+}
+
+// Helper to find a class by name and die if it isn't found.
+Class FindClassByName(NSString* nameOfClass) {
+  Class theClass = NSClassFromString(nameOfClass);
+  if (!theClass) {
+    LogError(@"Failed to find class %@ at runtime.", nameOfClass);
+    exit(EXIT_FAILURE);
+  }
+  return theClass;
+}
+
 // Converts the given app path to an application spec, which requires an
 // absolute path.
 DTiPhoneSimulatorApplicationSpecifier* BuildAppSpec(NSString* appPath) {
+  Class applicationSpecifierClass =
+      FindClassByName(@"DTiPhoneSimulatorApplicationSpecifier");
   if (![appPath isAbsolutePath]) {
     NSString* cwd = [[NSFileManager defaultManager] currentDirectoryPath];
     appPath = [cwd stringByAppendingPathComponent:appPath];
   }
   appPath = [appPath stringByStandardizingPath];
-  return [DTiPhoneSimulatorApplicationSpecifier
-      specifierWithApplicationPath:appPath];
+  return [applicationSpecifierClass specifierWithApplicationPath:appPath];
 }
 
 // Returns the system root for the given SDK version. If sdkVersion is nil, the
 // default system root is returned.  Will return nil if the sdkVersion is not
 // valid.
 DTiPhoneSimulatorSystemRoot* BuildSystemRoot(NSString* sdkVersion) {
-  DTiPhoneSimulatorSystemRoot* systemRoot =
-      [DTiPhoneSimulatorSystemRoot defaultRoot];
+  Class systemRootClass = FindClassByName(@"DTiPhoneSimulatorSystemRoot");
+  DTiPhoneSimulatorSystemRoot* systemRoot = [systemRootClass defaultRoot];
   if (sdkVersion)
-    systemRoot = [DTiPhoneSimulatorSystemRoot rootWithSDKVersion:sdkVersion];
+    systemRoot = [systemRootClass rootWithSDKVersion:sdkVersion];
 
   return systemRoot;
 }
 
 // Builds a config object for starting the specified app.
 DTiPhoneSimulatorSessionConfig* BuildSessionConfig(
     DTiPhoneSimulatorApplicationSpecifier* appSpec,
     DTiPhoneSimulatorSystemRoot* systemRoot,
     NSString* stdoutPath,
     NSString* stderrPath,
     NSArray* appArgs,
     NSDictionary* appEnv,
     NSNumber* deviceFamily) {
+  Class sessionConfigClass = FindClassByName(@"DTiPhoneSimulatorSessionConfig");
   DTiPhoneSimulatorSessionConfig* sessionConfig =
-      [[[DTiPhoneSimulatorSessionConfig alloc] init] autorelease];
+      [[[sessionConfigClass alloc] init] autorelease];
   sessionConfig.applicationToSimulateOnStart = appSpec;
   sessionConfig.simulatedSystemRoot = systemRoot;
   sessionConfig.localizedClientName = @"chromium";
   sessionConfig.simulatedApplicationStdErrPath = stderrPath;
   sessionConfig.simulatedApplicationStdOutPath = stdoutPath;
   sessionConfig.simulatedApplicationLaunchArgs = appArgs;
   sessionConfig.simulatedApplicationLaunchEnvironment = appEnv;
   sessionConfig.simulatedDeviceFamily = deviceFamily;
   return sessionConfig;
 }
 
 // Builds a simulator session that will use the given delegate.
 DTiPhoneSimulatorSession* BuildSession(SimulatorDelegate* delegate) {
+  Class sessionClass = FindClassByName(@"DTiPhoneSimulatorSession");
   DTiPhoneSimulatorSession* session =
-      [[[DTiPhoneSimulatorSession alloc] init] autorelease];
+      [[[sessionClass alloc] init] autorelease];
   session.delegate = delegate;
   return session;
 }
 
 // Creates a temporary directory with a unique name based on the provided
 // template. The template should not contain any path separators and be suffixed
 // with X's, which will be substituted with a unique alphanumeric string (see
 // 'man mkdtemp' for details). The directory will be created as a subdirectory
 // of NSTemporaryDirectory(). For example, if dirNameTemplate is 'test-XXX',
 // this method would return something like '/path/to/tempdir/test-3n2'.
@@ skipping 74 matching lines @@
       " Will create a new directory if not specified.\n"
       "  -e  Specifies an environment key=value pair that will be"
       " set in the simulated application's environment.\n");
 }
 
 }  // namespace
 
 int main(int argc, char* const argv[]) {
   NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
 
-  char* toolName = basename(argv[0]);
-  if (toolName != NULL)
-    gToolName = toolName;
+  // basename() may modify the passed in string and it returns a pointer to an
+  // internal buffer. Give it a copy to modify, and copy what it returns.
+  char* worker = strdup(argv[0]);
+  char* toolName = basename(worker);
+  if (toolName != NULL) {
+    toolName = strdup(toolName);
+    if (toolName != NULL)
+      gToolName = toolName;
+  }
+  if (worker != NULL)
+    free(worker);
 
   NSString* appPath = nil;
   NSString* appName = nil;
   NSString* sdkVersion = nil;
   NSString* deviceName = @"iPhone";
   NSString* simHomePath = nil;
   NSMutableArray* appArgs = [NSMutableArray array];
   NSMutableDictionary* appEnv = [NSMutableDictionary dictionary];
 
   // Parse the optional arguments
@@ skipping 41 matching lines @@
     appName = [appPath lastPathComponent];
     while (++optind < argc) {
       [appArgs addObject:[NSString stringWithUTF8String:argv[optind]]];
     }
   } else {
     LogError(@"Unable to parse command line arguments.");
     PrintUsage();
     exit(EXIT_FAILURE);
   }
 
+  NSString* developerDir = FindDeveloperDir();
+  if (!developerDir) {
+    LogError(@"Unable to find developer directory.");
+    exit(EXIT_FAILURE);
+  }
+
+  NSBundle* simulatorFramework = LoadSimulatorFramework(developerDir);
+  if (!simulatorFramework) {
+    LogError(@"Failed to load the Simulator Framework.");
+    exit(EXIT_FAILURE);
+  }
+
   // Make sure the app path provided is legit.
   DTiPhoneSimulatorApplicationSpecifier* appSpec = BuildAppSpec(appPath);
   if (!appSpec) {
     LogError(@"Invalid app path: %@", appPath);
     exit(EXIT_FAILURE);
   }
 
   // Make sure the SDK path provided is legit (or nil).
   DTiPhoneSimulatorSystemRoot* systemRoot = BuildSystemRoot(sdkVersion);
   if (!systemRoot) {
@@ skipping 37 matching lines @@
 
   // Create the config and simulator session.
   DTiPhoneSimulatorSessionConfig* config = BuildSessionConfig(appSpec,
                                                               systemRoot,
                                                               stdioPath,
                                                               stdioPath,
                                                               appArgs,
                                                               appEnv,
                                                               deviceFamily);
   SimulatorDelegate* delegate =
-  [[[SimulatorDelegate alloc] initWithStdioPath:stdioPath] autorelease];
+      [[[SimulatorDelegate alloc] initWithStdioPath:stdioPath] autorelease];
   DTiPhoneSimulatorSession* session = BuildSession(delegate);
 
   // Start the simulator session.
   NSError* error;
   BOOL started = [session requestStartWithConfig:config
                                          timeout:kSessionStartTimeoutSeconds
                                            error:&error];
 
   // Spin the runtime indefinitely. When the delegate gets the message that the
   // app has quit it will exit this program.
   if (started)
     [[NSRunLoop mainRunLoop] run];
   else
     LogError(@"Simulator failed to start: %@", [error localizedDescription]);
 
   // Note that this code is only executed if the simulator fails to start
   // because once the main run loop is started, only the delegate calling
   // exit() will end the program.
   [pool drain];
   return EXIT_FAILURE;
 }