Make clicking the restart bubble for crashed apps work.

apps/app_load_service.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_load_service.h"
 
 #include "apps/app_load_service_factory.h"
 #include "apps/launcher.h"
 #include "apps/shell_window_registry.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 25 matching lines @@
       this, chrome::NOTIFICATION_EXTENSION_HOST_DID_STOP_LOADING,
       content::NotificationService::AllSources());
   registrar_.Add(
       this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
       content::NotificationService::AllSources());
 }
 
 AppLoadService::~AppLoadService() {}
 
 void AppLoadService::RestartApplication(const std::string& extension_id) {
-  post_reload_actions_[extension_id].action_type = RESTART;
   ExtensionService* service = extensions::ExtensionSystem::Get(profile_)->
       extension_service();
   DCHECK(service);
   service->ReloadExtension(extension_id);
+  RestartPlatformApp(profile_, service->GetExtensionById(extension_id, false));

[tapted, 2013/12/12 06:54:52]

GetExtensionsById likes to return NULL a lot.. 

I think there's a pathological case for unpacked extensions, where the reload
needs some asynchronous file IO, so GetExtensionById returns NULL immediately
after ReloadExtension.

[koz (OOO until 15th September), 2013/12/13 03:33:56]

Ah, good spot! I've tried a different approach in the latest patchset - wait for
the NOTIFICATION_EXTENSION_LOADED instead of NOTIFICATION_HOST_DID_STOP_LOADING
because the former always fires for reloads. Doing so means we need to check for
registered events rather than actual listeners. Registered events are events
that an app app should have listeners for, even if the app isn't running, and we
need to check them because they are only converted into real listeners at
NOTIFICATION_EXTENSION_LOADED time, which means we can't assume that the
listeners will be populated in our own LOADED listener.

WDYT?

 }
 
 bool AppLoadService::LoadAndLaunch(const base::FilePath& extension_path,
                                    const CommandLine& command_line,
                                    const base::FilePath& current_dir) {
   ExtensionService* extension_service =
       ExtensionSystem::GetForBrowserContext(profile_)->extension_service();
   std::string extension_id;
   if (!extensions::UnpackedInstaller::Create(extension_service)->
           LoadFromCommandLine(base::FilePath(extension_path), &extension_id)) {
@@ skipping 26 matching lines @@
         break;
       std::map<std::string, PostReloadAction>::iterator it =
           post_reload_actions_.find(extension->id());
       if (it == post_reload_actions_.end())
         break;
 
       switch (it->second.action_type) {
         case LAUNCH:
           LaunchPlatformApp(profile_, extension);
           break;
-        case RESTART:
-          RestartPlatformApp(profile_, extension);
-          break;
         case LAUNCH_WITH_COMMAND_LINE:
           LaunchPlatformAppWithCommandLine(
               profile_, extension, &it->second.command_line,
               it->second.current_dir);
           break;
         default:
           NOTREACHED();
       }
 
       post_reload_actions_.erase(it);
@@ skipping 30 matching lines @@
         Extension::DISABLE_RELOAD) != 0;
   }
   return false;
 }
 
 bool AppLoadService::HasPostReloadAction(const std::string& extension_id) {
   return post_reload_actions_.find(extension_id) != post_reload_actions_.end();
 }
 
 }  // namespace apps