Prepare chrome_main_app_mode_mac.mm for 10.9

chrome/app_shim/chrome_main_app_mode_mac.mm

 // Copyright 2013 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.
 
 // On Mac, one can't make shortcuts with command-line arguments. Instead, we
 // produce small app bundles which locate the Chromium framework and load it,
 // passing the appropriate data. This is the entry point into the framework for
 // those app bundles.
 
 #import <Cocoa/Cocoa.h>
@@ skipping 462 matching lines @@
 // A ReplyEventHandler is a helper class to send an Apple Event to a process
 // and call a callback when the reply returns.
 //
 // This is used to 'ping' the main Chrome process -- once Chrome has sent back
 // an Apple Event reply, it's guaranteed that it has opened the IPC channel
 // that the app shim will connect to.
 @interface ReplyEventHandler : NSObject {
   base::Callback<void(bool)> onReply_;
   AEDesc replyEvent_;
 }
-// Sends an Apple Event to the process identified by |psn|, and calls |replyFn|
-// when the reply is received. Internally this creates a ReplyEventHandler,
-// which will delete itself once the reply event has been received.
-+ (void)pingProcess:(const ProcessSerialNumber&)psn
-            andCall:(base::Callback<void(bool)>)replyFn;
+
+// Sends an Apple Event to the process identified by the outer bundle
+// identifier, and calls |replyFn| when the reply is received. Internally this
+// creates a ReplyEventHandler, which will delete itself once the reply event
+// has been received.
++ (void)pingProcessAndCall:(base::Callback<void(bool)>)replyFn;
+
 @end
 
 @interface ReplyEventHandler (PrivateMethods)
 // Initialise the reply event handler. Doesn't register any handlers until
 // |-pingProcess:| is called. |replyFn| is the function to be called when the
 // Apple Event reply arrives.
 - (id)initWithCallback:(base::Callback<void(bool)>)replyFn;
 
-// Sends an Apple Event ping to the process identified by |psn| and registers
-// to listen for a reply.
-- (void)pingProcess:(const ProcessSerialNumber&)psn;
+// Returns the apple event that should be sent to the process.
+- (NSAppleEventDescriptor*)appleEventToSendToProcess;
+
+// Sends an Apple Event ping to the process identified by the bundle
+// identifier and registers to listen for a reply.
+- (void)pingProcess;
 
 // Called when a response is received from the target process for the ping sent
 // by |-pingProcess:|.
 - (void)message:(NSAppleEventDescriptor*)event
       withReply:(NSAppleEventDescriptor*)reply;
 
 // Calls |onReply_|, passing it |success| to specify whether the ping was
 // successful.
 - (void)closeWithSuccess:(bool)success;
+
 @end
 
 @implementation ReplyEventHandler
-+ (void)pingProcess:(const ProcessSerialNumber&)psn
-            andCall:(base::Callback<void(bool)>)replyFn {
+
++ (void)pingProcessAndCall:(base::Callback<void(bool)>)replyFn {
   // The object will release itself when the reply arrives, or possibly earlier
   // if an unrecoverable error occurs.
   ReplyEventHandler* handler =
       [[ReplyEventHandler alloc] initWithCallback:replyFn];
-  [handler pingProcess:psn];
+  [handler pingProcess];
 }
+
 @end
 
 @implementation ReplyEventHandler (PrivateMethods)
 - (id)initWithCallback:(base::Callback<void(bool)>)replyFn {
   if ((self = [super init])) {
     onReply_ = replyFn;
   }
   return self;
 }
 
-- (void)pingProcess:(const ProcessSerialNumber&)psn {
+- (void)pingProcess {
   // Register the reply listener.
   NSAppleEventManager* em = [NSAppleEventManager sharedAppleEventManager];
   [em setEventHandler:self
           andSelector:@selector(message:withReply:)
-        forEventClass:'aevt'
-           andEventID:'ansr'];
+        forEventClass:kCoreEventClass
+           andEventID:kAEAnswer];
+
   // Craft the Apple Event to send.
+  NSString* chromeBundleId = [base::mac::OuterBundle() bundleIdentifier];
   NSAppleEventDescriptor* target = [NSAppleEventDescriptor
-      descriptorWithDescriptorType:typeProcessSerialNumber
-                             bytes:&psn
-                            length:sizeof(psn)];
-  NSAppleEventDescriptor* initial_event =
+      descriptorWithDescriptorType:typeApplicationBundleID
+                              data:[chromeBundleId
+                                  dataUsingEncoding:NSUTF8StringEncoding]];
+
+  NSAppleEventDescriptor* initialEvent =
       [NSAppleEventDescriptor
           appleEventWithEventClass:app_mode::kAEChromeAppClass
                            eventID:app_mode::kAEChromeAppPing
                   targetDescriptor:target
                           returnID:kAutoGenerateReturnID
                      transactionID:kAnyTransactionID];
 
   // Note that AESendMessage effectively ignores kAEDefaultTimeout, because this
   // call does not pass kAEWantReceipt (which is deprecated and unsupported on
   // Mac). Instead, rely on OnPingChromeTimeout().
   OSStatus status = AESendMessage(
-      [initial_event aeDesc], &replyEvent_, kAEQueueReply, kAEDefaultTimeout);
+      [initialEvent aeDesc], &replyEvent_, kAEQueueReply, kAEDefaultTimeout);
   if (status != noErr) {
     OSSTATUS_LOG(ERROR, status) << "AESendMessage";
     [self closeWithSuccess:false];
   }
 }
 
+- (NSAppleEventDescriptor*)appleEventToSendToProcess {
+  // Register the reply listener.
+  NSAppleEventManager* em = [NSAppleEventManager sharedAppleEventManager];
+  [em setEventHandler:self
+          andSelector:@selector(message:withReply:)
+        forEventClass:kCoreEventClass
+           andEventID:kAEAnswer];
+  NSAppleEventDescriptor* initial_event = [NSAppleEventDescriptor
+      appleEventWithEventClass:app_mode::kAEChromeAppClass
+                       eventID:app_mode::kAEChromeAppPing
+              targetDescriptor:nil

[tapted, 2016/10/26 06:28:29]

It sounds like maybe this apple event simply isn't getting delivered. What
happens if we populate the targetDescriptor here?

Maybe the target needs to be +[NSAppleEventDescriptor
descriptorWithApplicationURL:bundle_url] -- with |bundle_url| the url created
inside OpenApplicationWithPath()

+                      returnID:kAutoGenerateReturnID
+                 transactionID:kAnyTransactionID];
+  return initial_event;
+}
+
 - (void)message:(NSAppleEventDescriptor*)event
       withReply:(NSAppleEventDescriptor*)reply {
   [self closeWithSuccess:true];
 }
 
 - (void)closeWithSuccess:(bool)success {
   onReply_.Run(success);
   NSAppleEventManager* em = [NSAppleEventManager sharedAppleEventManager];
-  [em removeEventHandlerForEventClass:'aevt' andEventID:'ansr'];
+  [em removeEventHandlerForEventClass:kCoreEventClass andEventID:kAEAnswer];
   [self release];
 }
+
 @end
 
 //-----------------------------------------------------------------------------
 
 extern "C" {
 
 // |ChromeAppModeStart()| is the point of entry into the framework from the app
 // mode loader. There are cases where the Chromium framework may have changed in
 // a way that is incompatible with an older shim (e.g. change to libc++ library
 // linking). The function name is versioned to provide a way to force shim
@@ skipping 76 matching lines @@
     if ([existing_chrome count] > 0)
       pid = [[existing_chrome objectAtIndex:0] processIdentifier];
   }
 
   AppShimController controller;
   base::MessageLoopForUI main_message_loop;
   base::PlatformThread::SetName("CrAppShimMain");
 
   // In tests, launching Chrome does nothing, and we won't get a ping response,
   // so just assume the socket exists.
   if (pid == -1 &&

[tapted, 2016/10/26 06:28:29]

So I just got another crazy idea: I think we can just remove this `pid == -1`
check. And in fact all the stuff above under "Find already running instances of
Chrome".

-[NSWorkspace launchApplicationAtURL:..] says it will find running versions of
Chrome for us...

That doesn't address the quitting-chrome issue, but it helps reduce the number
of codepaths we need to worry about.

       !base::CommandLine::ForCurrentProcess()->HasSwitch(
           app_mode::kLaunchedForTest)) {
     // Launch Chrome if it isn't already running.
-    ProcessSerialNumber psn;
     base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
     command_line.AppendSwitch(switches::kSilentLaunch);
 
     // If the shim is the app launcher, pass --show-app-list when starting a new
     // Chrome process to inform startup codepaths and load the correct profile.
     if (info->app_mode_id == app_mode::kAppListModeId) {
       command_line.AppendSwitch(switches::kShowAppList);
     } else {
       command_line.AppendSwitchPath(switches::kProfileDirectory,
                                     info->profile_dir);
     }
 
+    base::Callback<void(bool)> on_ping_chrome_reply = base::Bind(
+        &AppShimController::OnPingChromeReply, base::Unretained(&controller));
+
+    // Self-owned object that will delete itself.
+    ReplyEventHandler* handler =
+        [[ReplyEventHandler alloc] initWithCallback:on_ping_chrome_reply];
+    NSAppleEventDescriptor* descriptor = [handler appleEventToSendToProcess];
+
     base::Process app = base::mac::OpenApplicationWithPath(
-        base::mac::OuterBundlePath(), command_line, NSWorkspaceLaunchDefault);
-
-    // TODO(crbug.com/652563): Do not use deprecated GetProcessForPID. Change
-    // |ReplyEventHandler| to take |pid_t| instead of |ProcessSerialNumber|.
-    if (!app.IsValid() || GetProcessForPID(app.Pid(), &psn) != noErr)
+        base::mac::OuterBundlePath(), command_line, NSWorkspaceLaunchDefault,
+        descriptor);
+    if (!app.IsValid()) {
+      [handler closeWithSuccess:false];
       return 1;
-
-    base::Callback<void(bool)> on_ping_chrome_reply =
-        base::Bind(&AppShimController::OnPingChromeReply,
-                   base::Unretained(&controller));
+    }
 
     // This code abuses the fact that Apple Events sent before the process is
     // fully initialized don't receive a reply until its run loop starts. Once
     // the reply is received, Chrome will have opened its IPC port, guaranteed.
-    [ReplyEventHandler pingProcess:psn
-                           andCall:on_ping_chrome_reply];
+    [ReplyEventHandler pingProcessAndCall:on_ping_chrome_reply];
 
     main_message_loop.task_runner()->PostDelayedTask(
         FROM_HERE, base::Bind(&AppShimController::OnPingChromeTimeout,
                               base::Unretained(&controller)),
         base::TimeDelta::FromSeconds(kPingChromeTimeoutSeconds));
   } else {
     // Chrome already running. Proceed to init. This could still fail if Chrome
     // is still starting up or shutting down, but the process will exit quickly,
     // which is preferable to waiting for the Apple Event to timeout after one
     // minute.
     main_message_loop.task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&AppShimController::Init, base::Unretained(&controller)));
   }
 
   base::RunLoop().Run();
   return 0;
 }