Update component extension reload backoff logic.

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 262 matching lines @@
   -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) {
+    : prefs_(NULL),
+      extension_registry_observer_(this),
+      weak_ptr_factory_(this) {
   // Don't load/store preferences if the parent profile is incognito.
   if (!profile->IsOffTheRecord())
     prefs_ = profile->GetPrefs();
 
   // Listen for events to tell us when to load/unload persisted background
   // contents.
   StartObserving(profile);
 }
 
 BackgroundContentsService::~BackgroundContentsService() {
@@ skipping 177 matching lines @@
       // 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),
                              "background",
                              base::UTF8ToUTF16(extension->id()));
     }
   }
 
+  // If there is an existing BackoffEntry for the extension, clear it if
+  // the component extension stays loaded for 60 seconds. This avoids the
+  // situation of effectively disabling an extension for the entire browser
+  // session if there was a periodic crash (sometimes caused by another source).
+  if (extensions::Manifest::IsComponentLocation(extension->location())) {
+    ComponentExtensionBackoffEntryMap::const_iterator it =
+        component_backoff_map_.find(extension->id());
+    if (it != component_backoff_map_.end()) {
+      net::BackoffEntry* entry = component_backoff_map_[extension->id()].get();
+      base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(FROM_HERE,
+          base::Bind(&BackgroundContentsService::MaybeClearBackoffEntry,
+              weak_ptr_factory_.GetWeakPtr(), extension->id(),
+              entry->failure_count()),
+          base::TimeDelta::FromMilliseconds(60000 /* 60 seconds */));

[Wez, 2016/09/03 06:48:34]

nit: Just use FromSeconds directly?

[apacible, 2016/09/05 00:34:37]

Done.

+    }
+  }
+
   // Close the crash notification balloon for the app/extension, if any.
   ScheduleCloseBalloon(extension->id(), profile);
   SendChangeNotification(profile);
 }
 
 void BackgroundContentsService::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
     const extensions::Extension* extension,
     extensions::UnloadedExtensionInfo::Reason reason) {
   switch (reason) {
@@ skipping 42 matching lines @@
 }
 
 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());
+    ComponentExtensionBackoffEntryMap::const_iterator it =
+        component_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()) {
+    if (it == component_backoff_map_.end()) {
       std::unique_ptr<net::BackoffEntry> backoff_entry(
           new net::BackoffEntry(&kExtensionReloadBackoffPolicy));
-      backoff_map_.insert(
+      component_backoff_map_.insert(
           std::pair<extensions::ExtensionId,
                     std::unique_ptr<net::BackoffEntry>>(
               extension->id(), std::move(backoff_entry)));
     }
 
-    net::BackoffEntry* entry = backoff_map_[extension->id()].get();
+    net::BackoffEntry* entry = component_backoff_map_[extension->id()].get();
     entry->InformOfRequest(false);
     restart_delay = entry->GetTimeUntilRelease().InMilliseconds();
   }
 
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&ReloadExtension, extension->id(), profile),
       base::TimeDelta::FromMilliseconds(restart_delay));
 }
 
 // Loads all background contents whose urls have been stored in prefs.
@@ skipping 29 matching lines @@
   }
 }
 
 void BackgroundContentsService::SendChangeNotification(Profile* profile) {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_BACKGROUND_CONTENTS_SERVICE_CHANGED,
       content::Source<Profile>(profile),
       content::Details<BackgroundContentsService>(this));
 }
 
+void BackgroundContentsService::MaybeClearBackoffEntry(
+    const std::string extension_id,
+    int expected_failure_count) {
+  ComponentExtensionBackoffEntryMap::const_iterator it =
+      component_backoff_map_.find(extension_id);
+  if (it == component_backoff_map_.end())
+    return;
+
+  net::BackoffEntry* entry = component_backoff_map_[extension_id].get();
+
+  // Only remove the BackoffEntry if there has has been no failure for
+  // |extension_id| since loading.
+  if (entry->failure_count() == expected_failure_count)
+    component_backoff_map_.erase(it);
+}
+
 void BackgroundContentsService::LoadBackgroundContentsForExtension(
     Profile* profile,
     const std::string& extension_id) {
   // First look if the manifest specifies a background page.
   const Extension* extension =
       extensions::ExtensionSystem::Get(profile)->extension_service()->
           GetExtensionById(extension_id, false);
   DCHECK(!extension || extension->is_hosted_app());
   if (extension && BackgroundInfo::HasBackgroundPage(extension)) {
     LoadBackgroundContents(profile,
@@ skipping 206 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);
   }
 }