Test Keeping NaCl plugins used in app background pages alive when active.

extensions/browser/process_manager.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 "extensions/browser/process_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
@@ skipping 424 matching lines @@
     return;
 
   BackgroundPageData& bd = background_page_data_[extension->id()];
 
   if (!bd.keepalive_impulse) {
     bd.keepalive_impulse = true;
     if (!bd.previous_keepalive_impulse) {
       IncrementLazyKeepaliveCount(extension);
     }
   }
+
+  if (!keepalive_impulse_callback_for_testing_.is_null())
+    keepalive_impulse_callback_for_testing_.Run(extension->id());
 }
 
 // DecrementLazyKeepaliveCount is called when no calls to KeepaliveImpulse
 // have been made for at least event_page_idle_time_. In the best case an
 // impulse was made just before being cleared, and the decrement will occur
 // event_page_idle_time_ later, causing a 2 * event_page_idle_time_ total time
 // for extension to be shut down based on impulses. Worst case is an impulse
 // just after a clear, adding one check cycle and resulting in 3x total time.
 void ProcessManager::OnKeepaliveImpulseCheck() {
   for (BackgroundPageDataMap::iterator i = background_page_data_.begin();
        i != background_page_data_.end();
        ++i) {
-    if (i->second.previous_keepalive_impulse && !i->second.keepalive_impulse)
+    if (i->second.previous_keepalive_impulse && !i->second.keepalive_impulse) {
       DecrementLazyKeepaliveCount(i->first);
+      if (!keepalive_impulse_decrement_callback_for_testing_.is_null())
+        keepalive_impulse_decrement_callback_for_testing_.Run(i->first);
+    }
 
     i->second.previous_keepalive_impulse = i->second.keepalive_impulse;
     i->second.keepalive_impulse = false;
   }
 
   // OnKeepaliveImpulseCheck() is always called in constructor, but in unit
   // tests there will be no message loop. In that event don't schedule tasks.
   if (base::MessageLoop::current()) {
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
@@ skipping 100 matching lines @@
   if (!service || !service->is_ready())
     return;
 
   CreateBackgroundHostsForProfileStartup();
 }
 
 content::BrowserContext* ProcessManager::GetBrowserContext() const {
   return site_instance_->GetBrowserContext();
 }
 
+void ProcessManager::SetKeepaliveImpulseCallbackForTesting(
+    const ImpulseCallbackForTesting& callback) {
+  keepalive_impulse_callback_for_testing_ = callback;
+}
+
+void ProcessManager::SetKeepaliveImpulseDecrementCallbackForTesting(
+    const ImpulseCallbackForTesting& callback) {
+  keepalive_impulse_decrement_callback_for_testing_ = callback;
+}
+
 void ProcessManager::Observe(int type,
                              const content::NotificationSource& source,
                              const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_EXTENSIONS_READY:
     case chrome::NOTIFICATION_PROFILE_CREATED: {
        // Don't load background hosts now if the loading should be deferred.
        // Instead they will be loaded when a browser window for this profile
        // (or an incognito profile from this profile) is ready.
        if (DeferLoadingBackgroundHosts())
@@ skipping 284 matching lines @@
 }
 
 bool IncognitoProcessManager::IsIncognitoEnabled(const Extension* extension) {
   // Keep in sync with duplicate in extension_info_map.cc.
   ExtensionService* service = ExtensionSystem::GetForBrowserContext(
       GetBrowserContext())->extension_service();
   return extension_util::IsIncognitoEnabled(extension->id(), service);
 }
 
 }  // namespace extensions