Reload force-installed extensions on crash/force-close

chrome/browser/background/background_contents_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 "chrome/browser/background/background_contents_service.h"
 
 #include "apps/app_load_service.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 36 matching lines @@
 #include "ui/gfx/image/image.h"
 
 using content::SiteInstance;
 using content::WebContents;
 using extensions::BackgroundInfo;
 using extensions::Extension;
 using extensions::UnloadedExtensionInfo;
 
 namespace {
 
-const char kNotificationPrefix[] = "app.background.crashed.";
+const char kCrashNotificationPrefix[] = "app.background.crashed.";
+const char kMisbehaveNotificationPrefix[] = "app.background.misbehaved.";
+
+/** No. of recent crashes required to trigger an extension-misbehave popup **/

[bartfab (slow), 2013/08/26 13:26:53]

Nit 1: Do not use abbreviations: No. => Number
Nit 2: Note that this applies to force-installed apps/extensions only.

[anitawoodruff, 2013/08/26 21:45:23]

Done.

+const unsigned int kNCrashesShouldNotify = 5;

[bartfab (slow), 2013/08/26 13:26:53]

Nit: This constant does not follow the usual Chrome constant naming. It should
more be something like kForceInstalledExtensionCrashNotificationThreshold.

[anitawoodruff, 2013/08/26 21:45:23]

Done.

 
 void CloseBalloon(const std::string& id) {
   g_browser_process->notification_ui_manager()->CancelById(id);
 }
 
-void ScheduleCloseBalloon(const std::string& extension_id) {
+void ScheduleCloseBalloon(const std::string& id) {

[bartfab (slow), 2013/08/26 13:26:53]

Nit 1: "extension_id" identifies an extension; easy. What does "id" identify?

Nit 2: Add a comment that explains what these three methods do and how they
differ. The differences are subtle and hard to spot.

[anitawoodruff, 2013/08/26 21:45:23]

Done - is prefixed_extension_id ok? Or should I make up a new concept such as
balloon_id ?
Done. Is this clear enough now?

[bartfab (slow), 2013/08/27 09:21:29]

|prefixed_extension_id| is an accurate description of how this ID was generated
but not what it is used for. |notification_id| or |balloon_id| would be much
better.

[anitawoodruff, 2013/08/27 10:00:51]

Done.

   if (!base::MessageLoop::current())  // For unit_tests
     return;
   base::MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&CloseBalloon, kNotificationPrefix + extension_id));
+      FROM_HERE, base::Bind(&CloseBalloon, id));
+}
+
+void ScheduleCloseCrashBalloon(const std::string& extension_id) {
+  ScheduleCloseBalloon(kCrashNotificationPrefix + extension_id);
+}
+
+void ScheduleCloseBalloons(const std::string& extension_id) {
+  ScheduleCloseBalloon(kMisbehaveNotificationPrefix + extension_id);
+  ScheduleCloseBalloon(kCrashNotificationPrefix + extension_id);
 }
 
 class CrashNotificationDelegate : public NotificationDelegate {
  public:
   CrashNotificationDelegate(Profile* profile,
                             const Extension* extension)
       : profile_(profile),
         is_hosted_app_(extension->is_hosted_app()),
         is_platform_app_(extension->is_platform_app()),
         extension_id_(extension->id()) {
@@ skipping 22 matching lines @@
         service->LoadBackgroundContentsForExtension(profile_,
                                                     copied_extension_id);
     } else if (is_platform_app_) {
       apps::AppLoadService::Get(profile_)->
           RestartApplication(copied_extension_id);
     } else {
       extensions::ExtensionSystem::Get(profile_)->extension_service()->
           ReloadExtension(copied_extension_id);
     }
 
     // Closing the balloon here should be OK, but it causes a crash on Mac

[bartfab (slow), 2013/08/26 13:26:53]

Nit: "the balloon" is no longer unambiguous.

[anitawoodruff, 2013/08/26 21:45:23]

Done.

     // http://crbug.com/78167
-    ScheduleCloseBalloon(copied_extension_id);
+    ScheduleCloseCrashBalloon(copied_extension_id);
   }
 
   virtual bool HasClickedListener() OVERRIDE { return true; }
 
   virtual std::string id() const OVERRIDE {
-    return kNotificationPrefix + extension_id_;
+    return kCrashNotificationPrefix + extension_id_;
   }
 
   virtual content::RenderViewHost* GetRenderViewHost() const OVERRIDE {
     return NULL;
   }
 
  private:
   virtual ~CrashNotificationDelegate() {}
 
   Profile* profile_;
   bool is_hosted_app_;
   bool is_platform_app_;
   std::string extension_id_;
 
   DISALLOW_COPY_AND_ASSIGN(CrashNotificationDelegate);
 };
 
+class MisbehaveNotificationDelegate : public NotificationDelegate {

[bartfab (slow), 2013/08/26 13:26:53]

Nit 1: #include "chrome/browser/notifications/notification_delegate.h"

Nit 2: Add comments that note what CrashNotificationDelegate and
MisbehaveNotificationDelegate are for.

[anitawoodruff, 2013/08/26 21:45:23]

Done.

+ public:
+  explicit MisbehaveNotificationDelegate(const Extension* extension)
+      : extension_id_(extension->id()) {
+  }
+
+  virtual void Display() OVERRIDE {}
+
+  virtual void Error() OVERRIDE {}
+
+  virtual void Close(bool by_user) OVERRIDE {}
+
+  virtual void Click() OVERRIDE {}
+
+  virtual bool HasClickedListener() OVERRIDE { return true; }
+
+  virtual std::string id() const OVERRIDE {
+    return kMisbehaveNotificationPrefix + extension_id_;
+  }
+
+  virtual content::RenderViewHost* GetRenderViewHost() const OVERRIDE {
+    return NULL;
+  }
+
+ private:
+  virtual ~MisbehaveNotificationDelegate() {}
+
+  std::string extension_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(MisbehaveNotificationDelegate);
+};
+
 #if defined(ENABLE_NOTIFICATIONS)
 void NotificationImageReady(
     const std::string extension_name,
     const string16 message,
     const GURL extension_url,
-    scoped_refptr<CrashNotificationDelegate> delegate,
+    scoped_refptr<NotificationDelegate> delegate,
     Profile* profile,
     const gfx::Image& icon) {
   gfx::Image notification_icon(icon);
   if (icon.IsEmpty()) {
     ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
     notification_icon = rb.GetImageNamed(IDR_EXTENSION_DEFAULT_ICON);
   }
   string16 title;  // no notification title
   DesktopNotificationService::AddIconNotification(extension_url,
                                                   title,
                                                   message,
                                                   notification_icon,
                                                   string16(),
                                                   delegate.get(),
                                                   profile);
 }
 #endif
 
-void ShowBalloon(const Extension* extension, Profile* profile) {
+void ReloadExtension(const Extension* extension, Profile* profile) {
+  extensions::ExtensionSystem* extensionSystem =
+      extensions::ExtensionSystem::Get(profile);
+  if (extensionSystem && extensionSystem->extension_service())
+    extensionSystem->extension_service()->ReloadExtension(extension->id());
+}
+
+void ShowBalloon(const Extension* extension, Profile* profile, bool isForced) {

[bartfab (slow), 2013/08/26 13:26:53]

Nit: Add a comment explaining the parameters. "isForced" sounds like the balloon
is being forced :).

[anitawoodruff, 2013/08/26 21:45:23]

Done.

 #if defined(ENABLE_NOTIFICATIONS)
-  string16 message = l10n_util::GetStringFUTF16(
-      extension->is_app() ? IDS_BACKGROUND_CRASHED_APP_BALLOON_MESSAGE :
-                            IDS_BACKGROUND_CRASHED_EXTENSION_BALLOON_MESSAGE,
-      UTF8ToUTF16(extension->name()));
-
+  string16 message;
+  if (isForced) {
+    message = l10n_util::GetStringFUTF16(
+        extension->is_app() ?
+            IDS_BACKGROUND_MISBEHAVING_APP_BALLOON_MESSAGE :
+            IDS_BACKGROUND_MISBEHAVING_EXTENSION_BALLOON_MESSAGE,
+        UTF8ToUTF16(extension->name()));
+  } else {
+    message = l10n_util::GetStringFUTF16(
+        extension->is_app() ? IDS_BACKGROUND_CRASHED_APP_BALLOON_MESSAGE :
+                              IDS_BACKGROUND_CRASHED_EXTENSION_BALLOON_MESSAGE,
+        UTF8ToUTF16(extension->name()));
+  }
   extension_misc::ExtensionIcons size(extension_misc::EXTENSION_ICON_MEDIUM);
   extensions::ExtensionResource resource =
       extensions::IconsInfo::GetIconResource(
           extension, size, ExtensionIconSet::MATCH_SMALLER);
-  scoped_refptr<CrashNotificationDelegate> delegate =
-    new CrashNotificationDelegate(profile, extension);
+  scoped_refptr<NotificationDelegate> delegate = NULL;

[bartfab (slow), 2013/08/26 13:26:53]

Nit 1: You could set the delegate in the if-block above.
Nit 2: scoped_refptr initializes itself to NULL automatically. No need to do it
explicitly.

[anitawoodruff, 2013/08/26 21:45:23]

Done.

+  if (isForced)
+    delegate = new MisbehaveNotificationDelegate(extension);
+  else
+    delegate = new CrashNotificationDelegate(profile, extension);
   // We can't just load the image in the Observe method below because, despite
   // what this method is called, it may call the callback synchronously.
   // However, it's possible that the extension went away during the interim,
   // so we'll bind all the pertinent data here.
   extensions::ImageLoader::Get(profile)->LoadImageAsync(
       extension,
       resource,
       gfx::Size(size, size),
       base::Bind(
           &NotificationImageReady,
@@ skipping 15 matching lines @@
 //
 // kRegisteredBackgroundContents:
 //    DictionaryValue {
 //       <appid_1>: { "url": <url1>, "name": <frame_name> },
 //       <appid_2>: { "url": <url2>, "name": <frame_name> },
 //         ... etc ...
 //    }
 const char kUrlKey[] = "url";
 const char kFrameNameKey[] = "name";
 
+/** Delay (in seconds) before restarting a forced extension that crashed **/

[bartfab (slow), 2013/08/26 13:26:53]

Nit 1: s/forced/force-installed/
Nit 2: Move the comment to the header file instead.
Nit 3: We use //, not /** **/ in Chrome.

[anitawoodruff, 2013/08/26 21:45:23]

Done.

+base::TimeDelta BackgroundContentsService::restart_delay_ =
+    base::TimeDelta::FromSeconds(3);
+
+/** Seconds since a crash-reload during which we listen for further crashes **/

[bartfab (slow), 2013/08/26 13:26:53]

This comment is not quite correct. With the default settings, we wait for 5
crashes to happen in a 5 * (3 + 1) = 20 second window. 5 * 3 = 15 seconds are
just waiting for restarts to happen. But the crashes can occur anywhere within
the remaining 5 seconds, not just one crash per 1-second window.

[anitawoodruff, 2013/08/26 21:45:23]

I know it's not, but I can't for the life of me think how to phrase that! Is it
ok to have a 5 line explanation for one static variable? Even now I don't think
it's clear. Can you think of a snappy summary?

[bartfab (slow), 2013/08/27 09:21:29]

It is OK to have a long comment if a variable is unclear otherwise. In general,
Chrome has few and terse comments but that does not mean you are not allowed to
explain things well when needed. As with everything, it is a judgment call.

+base::TimeDelta BackgroundContentsService::crash_window_ =
+    base::TimeDelta::FromSeconds(1);
+
 BackgroundContentsService::BackgroundContentsService(
     Profile* profile, const CommandLine* command_line)
     : prefs_(NULL) {
   // Don't load/store preferences if the proper switch is not enabled, or if
   // the parent profile is incognito.
   if (!profile->IsOffTheRecord() &&
       !command_line->HasSwitch(switches::kDisableRestoreBackgroundContents))
     prefs_ = profile->GetPrefs();
 
   // Listen for events to tell us when to load/unload persisted background
   // contents.
   StartObserving(profile);
 }
 
 BackgroundContentsService::~BackgroundContentsService() {
   // BackgroundContents should be shutdown before we go away, as otherwise
   // our browser process refcount will be off.
   DCHECK(contents_map_.empty());
 }
 
+// static
+void BackgroundContentsService::SetCrashDelaysForTesting(
+    const base::TimeDelta& restart_delay, const base::TimeDelta& crash_window) {
+  restart_delay_ = restart_delay;
+  crash_window_ = crash_window;
+}
+
 std::vector<BackgroundContents*>
 BackgroundContentsService::GetBackgroundContents() const
 {
   std::vector<BackgroundContents*> contents;
   for (BackgroundContentsMap::const_iterator it = contents_map_.begin();
        it != contents_map_.end(); ++it)
     contents.push_back(it->second.contents);
   return contents;
 }
 
@@ skipping 104 matching lines @@
         if (service && service->is_ready()) {
           // Now load the manifest-specified background page. If service isn't
           // ready, then the background page will be loaded from the
           // EXTENSIONS_READY callback.
           LoadBackgroundContents(profile,
                                  BackgroundInfo::GetBackgroundURL(extension),
                                  ASCIIToUTF16("background"),
                                  UTF8ToUTF16(extension->id()));
         }
       }
-
       // Remove any "This extension has crashed" balloons.
-      ScheduleCloseBalloon(extension->id());
+      ScheduleCloseCrashBalloon(extension->id());
       SendChangeNotification(profile);
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED:
     case chrome::NOTIFICATION_BACKGROUND_CONTENTS_TERMINATED: {
       Profile* profile = content::Source<Profile>(source).ptr();
       const Extension* extension = NULL;
       if (type == chrome::NOTIFICATION_BACKGROUND_CONTENTS_TERMINATED) {
         BackgroundContents* bg =
             content::Details<BackgroundContents>(details).ptr();
         std::string extension_id = UTF16ToASCII(
             BackgroundContentsServiceFactory::GetForProfile(profile)->
                 GetParentApplicationId(bg));
         extension =
           extensions::ExtensionSystem::Get(profile)->extension_service()->
               GetExtensionById(extension_id, false);
       } else {
         extensions::ExtensionHost* extension_host =
             content::Details<extensions::ExtensionHost>(details).ptr();
         extension = extension_host->extension();
       }
       if (!extension)
         break;
 
       // When an extension crashes, EXTENSION_PROCESS_TERMINATED is followed by
-      // an EXTENSION_UNLOADED notification. This UNLOADED signal causes all the
-      // notifications for this extension to be cancelled by
-      // DesktopNotificationService. For this reason, instead of showing the
-      // balloon right now, we schedule it to show a little later.
-      base::MessageLoop::current()->PostTask(
-          FROM_HERE, base::Bind(&ShowBalloon, extension, profile));
+      // an EXTENSION_UNLOADED notification. We post the crash handling code as

[bartfab (slow), 2013/08/26 13:26:53]

The previous comment had more information on why popping up the balloon straight
away is not the right thing to do. Please re-add that part.

[anitawoodruff, 2013/08/26 21:45:23]

Done.

+      // a task here so it is not executed before the EXTENSION_UNLOADED event.
+      bool forceInstalled =
+          extension->location() ==
+              extensions::Manifest::EXTERNAL_POLICY_DOWNLOAD;
+      if (!forceInstalled) {
+        // Notify user extension has crashed.
+        base::MessageLoop::current()->PostTask(
+            FROM_HERE, base::Bind(&ShowBalloon, extension, profile, false));
+      } else {
+        // Restart the extension; notify user if crash recurs frequently.

[bartfab (slow), 2013/08/26 13:26:53]

I think this code is complex enough to warrant putting it into a separate
method.

[anitawoodruff, 2013/08/26 21:45:23]

Done.

+        const std::string& id = extension->id();

[bartfab (slow), 2013/08/26 13:26:53]

Nit: Why not call the variable extension_id?

[anitawoodruff, 2013/08/26 21:45:23]

Done.

+        const bool alreadyNotified =
+            misbehaving_extensions_.find(id) != misbehaving_extensions_.end();
+        std::queue<base::TimeTicks>& crashes = extension_crashlog_map_[id];
+        const base::TimeDelta duration =
+            kNCrashesShouldNotify * (restart_delay_ + crash_window_);
+        if (!alreadyNotified && crashes.size() == (kNCrashesShouldNotify - 1) &&

[bartfab (slow), 2013/08/26 13:26:53]

Please put the calculation on its own line and explain what it does. It is too
complex to follow like this IMHO.

[anitawoodruff, 2013/08/26 21:45:23]

Done.

+            base::TimeTicks::Now() - crashes.front() < duration) {
+          base::MessageLoop::current()->PostTask(FROM_HERE,
+              base::Bind(&ShowBalloon, extension, profile, true));
+          misbehaving_extensions_.insert(id);
+          extension_crashlog_map_.erase(id);
+        } else if (!alreadyNotified) {
+          while (!crashes.empty() &&
+                 base::TimeTicks::Now() - crashes.front() > duration) {
+            crashes.pop(); // Remove old timestamps.
+          }
+          crashes.push(base::TimeTicks::Now());
+          if (crashes.size() == kNCrashesShouldNotify)
+            crashes.pop();
+        }
+        base::MessageLoop::current()->PostDelayedTask(FROM_HERE,

[bartfab (slow), 2013/08/26 13:26:53]

This task will run 3s later. What if |extension| or |profile| (both pointers)
becomes invalid before that, e.g. because the extension is uninstalled during
the 3s window?

* For |profile|, you may be OK. You only use it in
ExtensionSystem::Get(profile). If that method can handle a nonexistent profile
(you should read its code to make sure this is the case), you are good.

* For |extension|, accessing |extension->id()| in the delayed task is dangerous.
You could access extension->id() here now and pass the resulting |std::string|
to the delayed task. Make sure though that
extension_service()->ReloadExtension() can handle an extension id that may no
longer exist.

* What will ReloadExtension() do if the extension has been uninstalled since -
will it reinstall it? That would be bad. 

[anitawoodruff, 2013/08/26 21:45:23]

I traced it through to
BrowserContextKeyedBaseFactory::GetBrowserContextToUse(context), and there is an
AssertBrowserContextWasntDestroyed(context) call, within a #ifndef NDEBUG, which
calls NOTREACHED if it doesn't find a context .. so I think this might be an
issue. Suggestions?
 
I'm not sure it does handle non-existent ones.. How do I check if it still
exists? Then I could do that in my ReloadExtension method before calling
extension_service()->ReloadExtension().
err I'm trying to understand the code here, I'm not sure but I think there is a
danger it might do just that - it checks 'if what we're loading was already
installed', and if not does 
    extensions::UnpackedInstaller::Create(this)->Load(path); <-- will this
reinstall an extension? (Does 'path' mean anything for force-installed
extensions? It gets cached on UnloadExtension, and doesn't get cleared on
UninstallExtension, as far as I can tell, but maybe it only means something for
local unpacked extensions?)

[bartfab (slow), 2013/08/27 09:21:29]

Sounds like both issues may arise - we may end up installing a deinstalled
extension and we may end up accessing an invalid profile.

+            base::Bind(&ReloadExtension, extension, profile), restart_delay_);
+      }
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_UNLOADED:
       switch (content::Details<UnloadedExtensionInfo>(details)->reason) {
         case extension_misc::UNLOAD_REASON_DISABLE:    // Fall through.
         case extension_misc::UNLOAD_REASON_TERMINATE:  // Fall through.
         case extension_misc::UNLOAD_REASON_UNINSTALL:  // Fall through.
         case extension_misc::UNLOAD_REASON_BLACKLIST:
           ShutdownAssociatedBackgroundContents(
               ASCIIToUTF16(content::Details<UnloadedExtensionInfo>(details)->
@@ skipping 16 matching lines @@
         default:
           NOTREACHED();
           ShutdownAssociatedBackgroundContents(
               ASCIIToUTF16(content::Details<UnloadedExtensionInfo>(details)->
                   extension->id()));
           break;
       }
       break;
 
     case chrome::NOTIFICATION_EXTENSION_UNINSTALLED: {
+      const std::string& extension_id =
+          content::Details<const Extension>(details).ptr()->id();
       // Remove any "This extension has crashed" balloons.
-      ScheduleCloseBalloon(
-          content::Details<const Extension>(details).ptr()->id());
+      ScheduleCloseBalloons(extension_id);
+      misbehaving_extensions_.erase(extension_id);
+      extension_crashlog_map_.erase(extension_id);
       break;
     }
 
     default:
       NOTREACHED();
       break;
   }
 }
 
 // Loads all background contents whose urls have been stored in prefs.
@@ skipping 211 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));
+  ScheduleCloseBalloons(UTF16ToASCII(details->application_id));

[bartfab (slow), 2013/08/26 13:26:53]

Will this not close the "misbehaving app" balloon when the app has reloaded?
IIUC, the balloon was meant to stay up, even if the app keeps crashing and
reloading.

[anitawoodruff, 2013/08/26 21:45:23]

Done.

 }
 
 // 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 27 matching lines @@
     bool user_gesture,
     bool* was_blocked) {
   Browser* browser = chrome::FindLastActiveWithProfile(
       Profile::FromBrowserContext(new_contents->GetBrowserContext()),
       chrome::GetActiveDesktop());
   if (browser) {
     chrome::AddWebContents(browser, NULL, new_contents, disposition,
                            initial_pos, user_gesture, was_blocked);
   }
 }