Use exponential backoff for component extension reloads.

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 <utility>
 
 #include "apps/app_load_service.h"
 #include "base/bind.h"
@@ skipping 245 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";
 
+// Defines the backoff policy used for attempting to reload extensions.
+const net::BackoffEntry::Policy kExtensionReloadBackoffPolicy = {
+  0,                // Initial errors to ignore before applying backoff.
+  3000,             // Initial delay: 3 seconds.
+  2,                // Multiply factor.
+  0.1,              // Fuzzing percentage.
+  -1,               // Maximum backoff time: -1 for no maximum.
+  -1,               // Entry lifetime: -1 to never discard.
+  false,            // Whether to always use initial delay. No-op as there are
+                    // no initial errors to ignore.
+};
+
 int BackgroundContentsService::restart_delay_in_ms_ = 3000;  // 3 seconds.
 
 BackgroundContentsService::BackgroundContentsService(
     Profile* profile,
     const base::CommandLine* command_line)
     : prefs_(NULL), extension_registry_observer_(this) {
   // Don't load/store preferences if the parent profile is incognito.
   if (!profile->IsOffTheRecord())
     prefs_ = profile->GetPrefs();
 
@@ skipping 240 matching lines @@
   // Make sure the extension-crash balloons are removed when the extension is
   // uninstalled/reloaded. We cannot do this from UNLOADED since a crashed
   // extension is unloaded immediately after the crash, not when user reloads or
   // uninstalls the extension.
   ScheduleCloseBalloon(extension->id(), profile);
 }
 
 void BackgroundContentsService::RestartForceInstalledExtensionOnCrash(
     const Extension* extension,
     Profile* profile) {
+  int restart_delay = restart_delay_in_ms_;
+
+  // If the extension was a component extension, use exponential backoff when
+  // attempting to reload.
+  if (extensions::Manifest::IsComponentLocation(extension->location())) {
+    ExtensionBackoffEntryMap::const_iterator it =
+        backoff_map_.find(extension->id());
+
+    // Create a BackoffEntry if this is the first time we try to reload this
+    // particular extension.
+    if (it == backoff_map_.end()) {
+      std::unique_ptr<net::BackoffEntry> backoff_entry(
+          new net::BackoffEntry(&kExtensionReloadBackoffPolicy));
+      backoff_map_.insert(

[Wez, 2016/09/01 21:47:58]

You're inserting a new entry into backoff_map_ here but never erase()ing it -
should it be cleaned-up similarly to content_map_, so that we can have a
destructor DCHECK(empty) as we do for that?

[apacible, 2016/09/02 00:20:32]

Good catch. I'll address this in a follow up CL.

+          std::pair<extensions::ExtensionId,
+                    std::unique_ptr<net::BackoffEntry>>(
+              extension->id(), std::move(backoff_entry)));
+    }
+
+    net::BackoffEntry* entry = backoff_map_[extension->id()].get();
+    entry->InformOfRequest(false);
+    restart_delay = entry->GetTimeUntilRelease().InMilliseconds();

[Wez, 2016/09/01 21:47:58]

When do we re-set the backoff for an extension, if ever?

e.g. if an extension happens to hit a crash every so often then won't the
restart delay still ramp up, over time, to some arbitrary level?

e.g. if WebRTC sometimes crashes the MR extension then after a dozen crashes the
Cast feature will seem to be completely broken?

[apacible, 2016/09/02 00:20:32]

We currently do not reset the backoff within the same browser session.

Chatted offline - it would make sense reset the backoff entry after the
background contents normally shuts down or after has been running continuously
for a fixed time (e.g. one minute).

+  }
+
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&ReloadExtension, extension->id(), profile),
-      base::TimeDelta::FromMilliseconds(restart_delay_in_ms_));
+      base::TimeDelta::FromMilliseconds(restart_delay));
 }
 
 // Loads all background contents whose urls have been stored in prefs.
 void BackgroundContentsService::LoadBackgroundContentsFromPrefs(
     Profile* profile) {
   if (!prefs_)
     return;
   const base::DictionaryValue* contents =
       prefs_->GetDictionary(prefs::kRegisteredBackgroundContents);
   if (!contents)
@@ skipping 248 matching lines @@
     const gfx::Rect& initial_rect,
     bool user_gesture,
     bool* was_blocked) {
   Browser* browser = chrome::FindLastActiveWithProfile(
       Profile::FromBrowserContext(new_contents->GetBrowserContext()));
   if (browser) {
     chrome::AddWebContents(browser, NULL, new_contents, disposition,
                            initial_rect, user_gesture, was_blocked);
   }
 }