Show an InfoBar when trying to start Packaged Apps from Metro mode.

apps/app_restore_service.cc

 // 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.
 
 #include "apps/app_restore_service.h"
 
+#include "apps/pref_names.h"
+#include "base/bind.h"
+#include "base/message_loop.h"
+#include "base/prefs/pref_service.h"
+#include "base/time.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/app_runtime/app_runtime_api.h"
 #include "chrome/browser/extensions/api/file_handlers/app_file_handler_util.h"
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_set.h"
 #include "content/public/browser/notification_details.h"
@@ skipping 31 matching lines @@
       it != extensions->end(); ++it) {
     const Extension* extension = *it;
     if (extension_prefs->IsExtensionRunning(extension->id())) {
       std::vector<SavedFileEntry> file_entries;
       extension_prefs->GetSavedFileEntries(extension->id(), &file_entries);
       RecordAppStop(extension->id());
       if (should_restore_apps)
         RestoreApp(*it, file_entries);
     }
   }
+
+  MaybeHandleMetroRelaunch(extension_service);
 }
 
 void AppRestoreService::Observe(int type,
                                 const content::NotificationSource& source,
                                 const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING: {
       ExtensionHost* host = content::Details<ExtensionHost>(details).ptr();
       const Extension* extension = host->extension();
       if (extension && extension->is_platform_app())
@@ skipping 32 matching lines @@
   extension_prefs->ClearSavedFileEntries(extension_id);
 }
 
 void AppRestoreService::RestoreApp(
     const Extension* extension,
     const std::vector<SavedFileEntry>& file_entries) {
   // TODO(koz): Make |file_entries| available to the newly restarted app.
   AppEventRouter::DispatchOnRestartedEvent(profile_, extension);
 }
 
+void AppRestoreService::LaunchAppWithId(const std::string& extension_id) {

[benwells, 2013/03/15 00:39:04]

I would prefer all this in a different PKS dedicated to this purpose. You could
then make it _win.* instead of #if.

[tapted, 2013/03/15 00:51:16]

I'll try that out.

Although I think the #if is still necessary, except it would go in
StartupBrowserCreatorImpl::ProcessStartupURLs, with some extra logic just below
where AppRestoreService currently is.

+  ExtensionService* extension_service =
+      ExtensionSystem::Get(profile_)->extension_service();
+  const Extension* extension =
+      extension_service->GetExtensionById(extension_id, false);
+  // There is a possibility of the extension getting uninstalled.
+  if (!extension)
+    return;
+
+  extensions::AppEventRouter::DispatchOnLaunchedEvent(profile_, extension);
+}
+
+void AppRestoreService::MaybeHandleMetroRelaunch(
+    ExtensionService* extension_service) {
+#if defined(OS_WIN)
+  const int kRestartAppLaunchDelayMs = 1000;
+  PrefService* prefs = g_browser_process->local_state();
+  if (!prefs->HasPrefPath(prefs::kRestartFromMetroWithAppLaunch))
+    return;
+
+  std::string extension_id =
+      prefs->GetString(prefs::kRestartFromMetroWithAppLaunch);
+  if (extension_id.empty())
+    return;
+
+  prefs->ClearPref(prefs::kRestartFromMetroWithAppLaunch);
+  MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&AppRestoreService::LaunchAppWithId,
+                 base::Unretained(this),
+                 extension_id),
+      base::TimeDelta::FromMilliseconds(kRestartAppLaunchDelayMs));
+#endif  // defined(OS_WIN)
+}
+
 }  // namespace apps