Fix a couple of crashes related to app-crashed balloon.

chrome/browser/background_contents_service.cc

 // Copyright (c) 2011 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 "chrome/browser/background_contents_service.h"
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 23 matching lines @@
 
 namespace {
 
 const char kNotificationPrefix[] = "app.background.crashed.";
 
 void CloseBalloon(const std::string id) {
   g_browser_process->notification_ui_manager()->CancelById(id);
 }
 
 void ScheduleCloseBalloon(const std::string& extension_id) {
+  if (!MessageLoop::current())  // For unit_tests
+    return;
   MessageLoop::current()->PostTask(FROM_HERE,
       NewRunnableFunction(&CloseBalloon,
           kNotificationPrefix + extension_id));
 }
 
 class CrashNotificationDelegate : public NotificationDelegate {
  public:
   CrashNotificationDelegate(Profile* profile, const Extension* extension)
       : profile_(profile),
         is_hosted_app_(extension->is_hosted_app()),
         extension_id_(extension->id()) {
   }
 
   ~CrashNotificationDelegate() {
   }
 
   void Display() {}
 
   void Error() {}
 
   void Close(bool by_user) {}
 
   void Click() {
     if (is_hosted_app_) {
-      BackgroundContentsServiceFactory::GetForProfile(profile_)->
-          LoadBackgroundContentsForExtension(profile_, extension_id_);
+      // There can be a race here: user clicks the balloon, and simultaneously
+      // reloads the sad tab for the app. So we check here to be safe before
+      // loading the background page.
+      BackgroundContentsService* service =
+          BackgroundContentsServiceFactory::GetForProfile(profile_);
+      if (!service->GetAppBackgroundContents(ASCIIToUTF16(extension_id_)))
+        service->LoadBackgroundContentsForExtension(profile_, extension_id_);
     } else {
       profile_->GetExtensionService()->ReloadExtension(extension_id_);
     }
 
     // Closing the balloon here should be OK, but it causes a crash on Mac
     // http://crbug.com/78167
     ScheduleCloseBalloon(extension_id_);
   }
 
   std::string id() const {
@@ skipping 142 matching lines @@
       Profile* profile = Source<Profile>(source).ptr();
       const string16& appid = GetParentApplicationId(bgcontents);
       ExtensionService* extension_service = profile->GetExtensionService();
       // extension_service can be NULL when running tests.
       if (extension_service) {
         const Extension* extension =
             extension_service->GetExtensionById(UTF16ToUTF8(appid), false);
         if (extension && extension->background_url().is_valid())
           break;
       }
-      RegisterBackgroundContents(Details<BackgroundContents>(details).ptr());
+      RegisterBackgroundContents(bgcontents);
       break;
     }
     case NotificationType::EXTENSION_LOADED: {
       const Extension* extension = Details<const Extension>(details).ptr();
       Profile* profile = Source<Profile>(source).ptr();
       if (extension->is_hosted_app() &&
           extension->background_url().is_valid()) {
         // If there is a background page specified in the manifest for a hosted
         // app, then blow away registered urls in the pref.
         ShutdownAssociatedBackgroundContents(ASCIIToUTF16(extension->id()));
@@ skipping 137 matching lines @@
 }
 
 void BackgroundContentsService::LoadBackgroundContentsFromDictionary(
     Profile* profile,
     const std::string& extension_id,
     const DictionaryValue* contents) {
   ExtensionService* extensions_service = profile->GetExtensionService();
   DCHECK(extensions_service);
 
   DictionaryValue* dict;
-  contents->GetDictionaryWithoutPathExpansion(extension_id, &dict);
-  if (dict == NULL)
+  if (!contents->GetDictionaryWithoutPathExpansion(extension_id, &dict) ||
+      dict == NULL)
     return;
+
   string16 frame_name;
   std::string url;
   dict->GetString(kUrlKey, &url);
   dict->GetString(kFrameNameKey, &frame_name);
   LoadBackgroundContents(profile,
                          GURL(url),
                          frame_name,
                          UTF8ToUTF16(extension_id));
 }
 
@@ skipping 108 matching lines @@
   }
 }
 
 void BackgroundContentsService::BackgroundContentsOpened(
     BackgroundContentsOpenedDetails* details) {
   // Add the passed object to our list. Should not already be tracked.
   DCHECK(!IsTracked(details->contents));
   DCHECK(!details->application_id.empty());
   contents_map_[details->application_id].contents = details->contents;
   contents_map_[details->application_id].frame_name = details->frame_name;
+
+  ScheduleCloseBalloon(UTF16ToASCII(details->application_id));
 }
 
 // Used by test code and debug checks to verify whether a given
 // BackgroundContents is being tracked by this instance.
 bool BackgroundContentsService::IsTracked(
     BackgroundContents* background_contents) const {
   return !GetParentApplicationId(background_contents).empty();
 }
 
 void BackgroundContentsService::BackgroundContentsShutdown(
@@ skipping 30 matching lines @@
     TabContents* new_contents,
     WindowOpenDisposition disposition,
     const gfx::Rect& initial_pos,
     bool user_gesture) {
   Browser* browser = BrowserList::GetLastActiveWithProfile(
       new_contents->profile());
   if (!browser)
     return;
   browser->AddTabContents(new_contents, disposition, initial_pos, user_gesture);
 }