Add a main menu to the shim that matches the one in Chrome.

apps/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>
 
 #include "apps/app_shim/app_shim_messages.h"
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/logging.h"
+#include "base/mac/bundle_locations.h"
 #include "base/mac/launch_services_util.h"
 #include "base/mac/mac_logging.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/threading/thread.h"
+#include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_paths_internal.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/mac/app_mode_common.h"
+#include "grit/generated_resources.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_message.h"
+#include "ui/base/resource/resource_bundle.h"
+#include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
 const app_mode::ChromeAppModeInfo* g_info;
 base::Thread* g_io_thread = NULL;
 
 }  // namespace
 
 class AppShimController;
 
@@ skipping 15 matching lines @@
 
 // The AppShimController is responsible for communication with the main Chrome
 // process, and generally controls the lifetime of the app shim process.
 class AppShimController : public IPC::Listener {
  public:
   AppShimController();
 
   // Connects to Chrome and sends a LaunchApp message.
   void Init();
 
+  // Builds main menu bar items.
+  void SetUpMenu();
+
   void SendSetAppHidden(bool hidden);
 
   void SendQuitApp();
 
   // Called when the app is activated, either by the user clicking on it in the
   // dock or by Cmd+Tabbing to it.
   void ActivateApp(bool is_reopen);
 
  private:
   // IPC::Listener implemetation.
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
   virtual void OnChannelError() OVERRIDE;
 
   // If Chrome failed to launch the app, |success| will be false and the app
   // shim process should die.
   void OnLaunchAppDone(apps::AppShimLaunchResult result);
 
-
   // Terminates the app shim process.
   void Close();
 
   IPC::ChannelProxy* channel_;
   base::scoped_nsobject<AppShimDelegate> nsapp_delegate_;
   bool launch_app_done_;
 
   DISALLOW_COPY_AND_ASSIGN(AppShimController);
 };
 
 AppShimController::AppShimController() : channel_(NULL),
                                          launch_app_done_(false) {}
 
 void AppShimController::Init() {
   DCHECK(g_io_thread);
+
+  SetUpMenu();
+
+  // Open an IPC channel to Chrome and send the initial app launch message.
   NSString* chrome_bundle_path =
       base::SysUTF8ToNSString(g_info->chrome_outer_bundle_path.value());
   NSBundle* chrome_bundle = [NSBundle bundleWithPath:chrome_bundle_path];
   base::FilePath user_data_dir;
   if (!chrome::GetUserDataDirectoryForBrowserBundle(chrome_bundle,
                                                     &user_data_dir)) {
     Close();
     return;
   }
 
   base::FilePath socket_path =
       user_data_dir.Append(app_mode::kAppShimSocketName);
   IPC::ChannelHandle handle(socket_path.value());
   channel_ = new IPC::ChannelProxy(handle, IPC::Channel::MODE_NAMED_CLIENT,
       this, g_io_thread->message_loop_proxy().get());
 
   channel_->Send(new AppShimHostMsg_LaunchApp(
       g_info->profile_dir, g_info->app_mode_id,
       CommandLine::ForCurrentProcess()->HasSwitch(app_mode::kNoLaunchApp) ?
           apps::APP_SHIM_LAUNCH_REGISTER_ONLY : apps::APP_SHIM_LAUNCH_NORMAL));
 
   nsapp_delegate_.reset([[AppShimDelegate alloc] initWithController:this]);
   DCHECK(![NSApp delegate]);
   [NSApp setDelegate:nsapp_delegate_];
 }
 
+void AppShimController::SetUpMenu() {
+  NSString* title = base::SysUTF16ToNSString(g_info->app_mode_name);
+
+  // Create a main menu since [NSApp mainMenu] is nil.
+  base::scoped_nsobject<NSMenu> main_menu([[NSMenu alloc] initWithTitle:title]);
+
+  // The title of the first item is replaced by OSX with the name of the app and
+  // bold styling. Create a dummy item for this and make it hidden.
+  NSMenuItem* dummy_item = [main_menu addItemWithTitle:title
+                                                action:nil
+                                         keyEquivalent:@""];
+  base::scoped_nsobject<NSMenu> dummy_submenu(
+      [[NSMenu alloc] initWithTitle:title]);
+  [dummy_item setSubmenu:dummy_submenu];
+  [dummy_item setHidden:YES];
+
+  // Construct an unbolded app menu, to match how it appears in the Chrome menu
+  // bar when the app is focused.
+  NSMenuItem* item = [main_menu addItemWithTitle:title
+                                          action:nil
+                                   keyEquivalent:@""];
+  base::scoped_nsobject<NSMenu> submenu([[NSMenu alloc] initWithTitle:title]);
+  [item setSubmenu:submenu];
+
+  // Add a quit entry.
+  NSString* quit_localized_string =
+      l10n_util::GetNSStringF(IDS_EXIT_MAC, g_info->app_mode_name);
+  [submenu addItemWithTitle:quit_localized_string
+                     action:@selector(terminate:)
+              keyEquivalent:@"q"];
+
+  [NSApp setMainMenu:main_menu];
+}
+
 void AppShimController::SendQuitApp() {
   channel_->Send(new AppShimHostMsg_QuitApp);
 }
 
 bool AppShimController::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(AppShimController, message)
     IPC_MESSAGE_HANDLER(AppShimMsg_LaunchApp_Done, OnLaunchAppDone)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
@@ skipping 216 matching lines @@
     RAW_LOG(ERROR, "App Mode Loader too old.");
     return 1;
   }
   if (info->major_version > app_mode::kCurrentChromeAppModeInfoMajorVersion) {
     RAW_LOG(ERROR, "Browser Framework too old to load App Shortcut.");
     return 1;
   }
 
   g_info = info;
 
+  // Set bundle paths. This loads the bundles.
+  base::mac::SetOverrideOuterBundlePath(g_info->chrome_outer_bundle_path);
+  base::mac::SetOverrideFrameworkBundlePath(
+      g_info->chrome_versioned_path.Append(chrome::kFrameworkName));
+
+  // Calculate the preferred locale used by Chrome.
+  // We can't use l10n_util::OverrideLocaleWithCocoaLocale() because
+  // [base::mac::OuterBundle() preferredLocalizations] seems to be equivalent to

[tapted, 2013/07/23 05:24:35]

'seems to be' -> 'is' ? (i.e. we should make sure this is the explanation)

And, I'm not too clear on why them being equivalent implies that we need to
calculate it separately. (i.e. my first thought is that it would mean we could
use either, rather than neither).

[jackhou1, 2013/07/23 06:22:22]

Updated the comment.

+  // [[NSBundle mainBundle] preferredLocalizations].
+  NSArray* preferred_languages = [NSLocale preferredLanguages];
+  NSArray* supported_languages = [base::mac::OuterBundle() localizations];
+  std::string preferred_localization;
+  for (NSString* language in preferred_languages) {
+    if ([supported_languages containsObject:language]) {
+      preferred_localization = base::SysNSStringToUTF8(language);
+      break;
+    }
+  }
+  std::string locale = l10n_util::NormalizeLocale(
+      l10n_util::GetApplicationLocale(preferred_localization));
+
+  // Load localized strings.
+  ResourceBundle::InitSharedInstanceLocaleOnly(locale, NULL);
+
   // Launch the IO thread.
   base::Thread::Options io_thread_options;
   io_thread_options.message_loop_type = base::MessageLoop::TYPE_IO;
   base::Thread *io_thread = new base::Thread("CrAppShimIO");
   io_thread->StartWithOptions(io_thread_options);
   g_io_thread = io_thread;
 
   // Find already running instances of Chrome.
-  NSString* chrome_bundle_path =
-      base::SysUTF8ToNSString(g_info->chrome_outer_bundle_path.value());
-  NSBundle* chrome_bundle = [NSBundle bundleWithPath:chrome_bundle_path];
+  NSString* chrome_bundle_id = [base::mac::OuterBundle() bundleIdentifier];
   NSArray* existing_chrome = [NSRunningApplication
-      runningApplicationsWithBundleIdentifier:[chrome_bundle bundleIdentifier]];
+      runningApplicationsWithBundleIdentifier:chrome_bundle_id];
 
   // Launch Chrome if it isn't already running.
   ProcessSerialNumber psn;
   if ([existing_chrome count] > 0) {
     OSStatus status = GetProcessForPID(
         [[existing_chrome objectAtIndex:0] processIdentifier], &psn);
     if (status)
       return 1;
 
   } else {
     CommandLine command_line(CommandLine::NO_PROGRAM);
     command_line.AppendSwitch(switches::kSilentLaunch);
     command_line.AppendSwitchPath(switches::kProfileDirectory,
                                   info->profile_dir);
     bool success =
-        base::mac::OpenApplicationWithPath(info->chrome_outer_bundle_path,
+        base::mac::OpenApplicationWithPath(base::mac::OuterBundlePath(),
                                            command_line,
                                            &psn);
     if (!success)
       return 1;
   }
 
   // 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:base::Bind(&OnPingChromeReply)];
 
   base::MessageLoopForUI main_message_loop;
   main_message_loop.set_thread_name("MainThread");
   base::PlatformThread::SetName("CrAppShimMain");
   main_message_loop.Run();
   return 0;
 }