Start app shim when app launched.

apps/app_shim/extension_app_shim_handler_mac.cc

 // 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.
 
 #include "apps/app_shim/extension_app_shim_handler_mac.h"
 
 #include "apps/app_shim/app_shim_messages.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/shell_window_registry.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
 #include "chrome/browser/ui/extensions/shell_window.h"
+#include "chrome/browser/web_applications/web_app.h"
 #include "ui/base/cocoa/focus_window_set.h"
 
 namespace apps {
 
-ExtensionAppShimHandler::ExtensionAppShimHandler() {}
+ExtensionAppShimHandler::ExtensionAppShimHandler() {
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_CREATED,
+                 content::NotificationService::AllBrowserContextsAndSources());
+}
 
 ExtensionAppShimHandler::~ExtensionAppShimHandler() {
   for (HostMap::iterator it = hosts_.begin(); it != hosts_.end(); ) {
     // Increment the iterator first as OnAppClosed may call back to OnShimClose
     // and invalidate the iterator.
     it++->second->OnAppClosed();
   }
 }
 
-bool ExtensionAppShimHandler::OnShimLaunch(Host* host) {
+bool ExtensionAppShimHandler::OnShimLaunch(Host* host, bool launch_now) {
   Profile* profile = host->GetProfile();
   DCHECK(profile);
 
   const std::string& app_id = host->GetAppId();
   if (!extensions::Extension::IdIsValid(app_id)) {
     LOG(ERROR) << "Bad app ID from app shim launch message.";
     return false;
   }
 
-  if (!LaunchApp(profile, app_id))
+  if (!LaunchApp(profile, app_id, launch_now))
     return false;
 
   // The first host to claim this (profile, app_id) becomes the main host.
-  // For any others, we launch the app but return false.
-  if (!hosts_.insert(make_pair(make_pair(profile, app_id), host)).second)
+  // For any others, we focus the app and return false.
+  if (!hosts_.insert(make_pair(make_pair(profile, app_id), host)).second) {
+    OnShimFocus(host);
     return false;
+  }
 
   if (!registrar_.IsRegistered(
       this, chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED,
       content::Source<Profile>(profile))) {
     registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED,
                    content::Source<Profile>(profile));
   }
 
   return true;
 }
@@ skipping 17 matching lines @@
       registry->GetShellWindowsForApp(host->GetAppId());
   std::set<gfx::NativeWindow> native_windows;
   for (extensions::ShellWindowRegistry::const_iterator i = windows.begin();
        i != windows.end(); ++i) {
     native_windows.insert((*i)->GetNativeWindow());
   }
   ui::FocusWindowSet(native_windows);
 }
 
 bool ExtensionAppShimHandler::LaunchApp(Profile* profile,
-                                        const std::string& app_id) {
+                                        const std::string& app_id,
+                                        bool launch_now) {
   extensions::ExtensionSystem* extension_system =
       extensions::ExtensionSystem::Get(profile);
   ExtensionServiceInterface* extension_service =
       extension_system->extension_service();
   const extensions::Extension* extension =
       extension_service->GetExtensionById(app_id, false);
   if (!extension) {
     LOG(ERROR) << "Attempted to launch nonexistent app with id '"
                << app_id << "'.";
     return false;
   }
+
+  if (!launch_now)
+    return true;
+
   // TODO(jeremya): Handle the case that launching the app fails. Probably we
   // need to watch for 'app successfully launched' or at least 'background page
   // exists/was created' and time out with failure if we don't see that sign of
   // life within a certain window.
   chrome::OpenApplication(chrome::AppLaunchParams(
       profile, extension, NEW_FOREGROUND_TAB));
   return true;
 }
 
 void ExtensionAppShimHandler::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   Profile* profile = content::Source<Profile>(source).ptr();
+  extensions::ExtensionHost* extension_host =
+      content::Details<extensions::ExtensionHost>(details).ptr();
   switch (type) {
-    case chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED: {
-      extensions::ExtensionHost* extension_host =
-          content::Details<extensions::ExtensionHost>(details).ptr();
+    case chrome::NOTIFICATION_EXTENSION_HOST_CREATED:
+      StartShim(profile, extension_host->extension());
+      break;
+    case chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED:
       CloseShim(profile, extension_host->extension_id());
       break;
-    }
     default:
       NOTREACHED();  // Unexpected notification.
       break;
   }
 }
 
+void ExtensionAppShimHandler::StartShim(
+    Profile* profile,
+    const extensions::Extension* extension) {
+  if (!extension->is_platform_app())
+    return;
+
+  if (hosts_.count(make_pair(profile, extension->id())))
+    return;
+
+  web_app::MaybeLaunchShortcut(profile, extension);
+}
+
 void ExtensionAppShimHandler::CloseShim(Profile* profile,
                                         const std::string& app_id) {
   HostMap::const_iterator it = hosts_.find(make_pair(profile, app_id));
   if (it != hosts_.end())
     it->second->OnAppClosed();
 }
 
 }  // namespace apps