Manifest handler for all keys background-related.

chrome/browser/extensions/event_router.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/extensions/event_router.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 12 matching lines @@
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/lazy_background_task_queue.h"
 #include "chrome/browser/extensions/process_map.h"
 #include "chrome/browser/extensions/system_info_event_router.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/api/extension_api.h"
+#include "chrome/common/extensions/background_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/view_type.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 
 using base::Value;
 using content::BrowserThread;
 
 namespace extensions {
@@ skipping 507 matching lines @@
     return true;
   }
 
   return false;
 }
 
 void EventRouter::IncrementInFlightEvents(Profile* profile,
                                           const Extension* extension) {
   // Only increment in-flight events if the lazy background page is active,
   // because that's the only time we'll get an ACK.
-  if (extension->has_lazy_background_page()) {
+  if (BackgroundInfo::HasLazyBackgroundPage(extension)) {
     ExtensionProcessManager* pm =
         ExtensionSystem::Get(profile)->process_manager();
     ExtensionHost* host = pm->GetBackgroundHostForExtension(extension->id());
     if (host)
       pm->IncrementLazyKeepaliveCount(extension);
   }
 }
 
 void EventRouter::OnEventAck(Profile* profile,
                              const std::string& extension_id) {
   ExtensionProcessManager* pm =
       ExtensionSystem::Get(profile)->process_manager();
   ExtensionHost* host = pm->GetBackgroundHostForExtension(extension_id);
   // The event ACK is routed to the background host, so this should never be
   // NULL.
   CHECK(host);
   // TODO(mpcomplete): We should never get this message unless
-  // has_lazy_background_page is true. Find out why we're getting it anyway.
-  if (host->extension() && host->extension()->has_lazy_background_page())
+  // HasLazyBackgroundPage is true. Find out why we're getting it anyway.
+  if (host->extension() &&
+      BackgroundInfo::HasLazyBackgroundPage(host->extension()))
     pm->DecrementLazyKeepaliveCount(host->extension());
 }
 
 void EventRouter::DispatchPendingEvent(const linked_ptr<Event>& event,
                                        ExtensionHost* host) {
   if (!host)
     return;
 
   if (listeners_.HasProcessListener(host->render_process_host(),
                                     host->extension()->id())) {
@@ skipping 17 matching lines @@
     case chrome::NOTIFICATION_EXTENSIONS_READY: {
       // We're done restarting Chrome after an update.
       dispatch_chrome_updated_event_ = false;
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_ENABLED: {
       // If the extension has a lazy background page, make sure it gets loaded
       // to register the events the extension is interested in.
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
-      if (extension->has_lazy_background_page()) {
+      if (BackgroundInfo::HasLazyBackgroundPage(extension)) {
         LazyBackgroundTaskQueue* queue =
             ExtensionSystem::Get(profile_)->lazy_background_task_queue();
         queue->AddPendingTask(profile_, extension->id(),
                               base::Bind(&DoNothing));
       }
     }
     case chrome::NOTIFICATION_EXTENSION_LOADED: {
       // Add all registered lazy listeners to our cache.
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
@@ skipping 92 matching lines @@
   copy->will_dispatch_callback = will_dispatch_callback;
   return copy;
 }
 
 EventListenerInfo::EventListenerInfo(const std::string& event_name,
                                      const std::string& extension_id)
     : event_name(event_name),
       extension_id(extension_id) {}
 
 }  // namespace extensions