Manifest handler for all keys background-related.

chrome/browser/extensions/extension_process_manager.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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time.h"
 #include "chrome/browser/extensions/api/runtime/runtime_api.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/view_type_utils.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/extensions/background_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_messages.h"
+#include "chrome/common/extensions/manifest_handler.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/renderer_preferences.h"
 
 #if defined(OS_MACOSX)
 #include "chrome/browser/extensions/extension_host_mac.h"
 #endif
 
 using content::BrowserThread;
 using content::OpenURLParams;
 using content::Referrer;
 using content::RenderViewHost;
 using content::SiteInstance;
 using content::WebContents;
+using extensions::BackgroundInfo;
+using extensions::BackgroundManifestHandler;
 using extensions::Extension;
 using extensions::ExtensionHost;
 
 namespace {
 
 std::string GetExtensionID(RenderViewHost* render_view_host) {
   // This works for both apps and extensions because the site has been
   // normalized to the extension URL for apps.
   if (!render_view_host->GetSiteInstance())
     return "";
@@ skipping 24 matching lines @@
                        const content::NotificationDetails& details) OVERRIDE;
 
   // Returns true if the extension is allowed to run in incognito mode.
   bool IsIncognitoEnabled(const Extension* extension);
 
   ExtensionProcessManager* original_manager_;
 };
 
 static void CreateBackgroundHostForExtensionLoad(
     ExtensionProcessManager* manager, const Extension* extension) {
-  if (extension->has_persistent_background_page())
-    manager->CreateBackgroundHost(extension, extension->GetBackgroundURL());
+  if (BackgroundInfo::HasPersistentBackgroundPage(extension))
+    manager->CreateBackgroundHost(extension,
+                                  BackgroundInfo::GetBackgroundURL(extension));
 }
 
 static void CreateBackgroundHostsForProfileStartup(
     Profile* profile,
     ExtensionProcessManager* manager,
     const ExtensionSet* extensions) {
   for (ExtensionSet::const_iterator extension = extensions->begin();
        extension != extensions->end(); ++extension) {
     CreateBackgroundHostForExtensionLoad(manager, *extension);
 
@@ skipping 71 matching lines @@
           switches::kEventPageIdleTime), &idle_time_sec)) {
     event_page_idle_time_ = base::TimeDelta::FromSeconds(idle_time_sec);
   }
   event_page_unloading_time_ = base::TimeDelta::FromSeconds(5);
   unsigned unloading_time_sec = 0;
   if (base::StringToUint(CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kEventPageUnloadingTime), &unloading_time_sec)) {
     event_page_unloading_time_ = base::TimeDelta::FromSeconds(
         unloading_time_sec);
   }
+
+  std::vector<std::string> background_keys(BackgroundManifestHandler::keys());

[Matt Perry, 2013/02/15 20:15:02]

This is cumbersome. How about making it a method on the handler:
  new BackgroundManifestHandler().Register();

[Matt Perry, 2013/02/15 20:15:02]

Also, it feels a little out of place here, but I can't think of a better place.
Maybe we should have an ExtensionCore class that registers all the handlers that
are central to extensions. Just spitballing...

[Yoyo Zhou, 2013/02/16 00:54:04]

Maybe we could call it ExtensionService? =)

Seriously, I think there are other such things that are specific to extensions
that are extensions/apps/platform apps.

[Yoyo Zhou, 2013/02/16 00:54:04]

I definitely considered this but I thought the ownership would be kind of
opaque. No more opaque than it is now, though. I'll change this throughout.

+  linked_ptr<BackgroundManifestHandler> background_handler(
+      new BackgroundManifestHandler);
+  for (size_t i = 0; i < background_keys.size(); ++i) {
+    extensions::ManifestHandler::Register(background_keys[i],
+                                          background_handler);
+  }
 }
 
 ExtensionProcessManager::~ExtensionProcessManager() {
   CloseBackgroundHosts();
   DCHECK(background_hosts_.empty());
 }
 
 const ExtensionProcessManager::ViewSet
 ExtensionProcessManager::GetAllViews() const {
   ViewSet result;
@@ skipping 222 matching lines @@
   return site_instance_->GetRelatedSiteInstance(url);
 }
 
 bool ExtensionProcessManager::IsBackgroundHostClosing(
     const std::string& extension_id) {
   ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
   return (host && background_page_data_[extension_id].is_closing);
 }
 
 int ExtensionProcessManager::GetLazyKeepaliveCount(const Extension* extension) {
-  if (!extension->has_lazy_background_page())
+  if (!BackgroundInfo::HasLazyBackgroundPage(extension))
     return 0;
 
   return background_page_data_[extension->id()].lazy_keepalive_count;
 }
 
 int ExtensionProcessManager::IncrementLazyKeepaliveCount(
      const Extension* extension) {
-  if (!extension->has_lazy_background_page())
+  if (!BackgroundInfo::HasLazyBackgroundPage(extension))
     return 0;
 
   int& count = background_page_data_[extension->id()].lazy_keepalive_count;
   if (++count == 1)
     OnLazyBackgroundPageActive(extension->id());
 
   return count;
 }
 
 int ExtensionProcessManager::DecrementLazyKeepaliveCount(
      const Extension* extension) {
-  if (!extension->has_lazy_background_page())
+  if (!BackgroundInfo::HasLazyBackgroundPage(extension))
     return 0;
 
   int& count = background_page_data_[extension->id()].lazy_keepalive_count;
   DCHECK_GT(count, 0);
   if (--count == 0) {
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&ExtensionProcessManager::OnLazyBackgroundPageIdle,
                    weak_ptr_factory_.GetWeakPtr(), extension->id(),
                    ++background_page_data_[extension->id()].close_sequence_id),
@@ skipping 252 matching lines @@
 Profile* ExtensionProcessManager::GetProfile() const {
   return Profile::FromBrowserContext(site_instance_->GetBrowserContext());
 }
 
 void ExtensionProcessManager::OnExtensionHostCreated(ExtensionHost* host,
                                                      bool is_background) {
   DCHECK_EQ(site_instance_->GetBrowserContext(), host->profile());
   if (is_background) {
     background_hosts_.insert(host);
 
-    if (host->extension()->has_lazy_background_page()) {
+    if (BackgroundInfo::HasLazyBackgroundPage(host->extension())) {
       linked_ptr<PerfTimer> since_unloaded(
           background_page_data_[host->extension()->id()].
               since_unloaded.release());
       if (since_unloaded.get()) {
         UMA_HISTOGRAM_LONG_TIMES("Extensions.EventPageIdleTime",
                                  since_unloaded->Elapsed());
       }
     }
   }
 }
@@ skipping 122 matching lines @@
           CreateBackgroundHostsForProfileStartup(GetProfile(),
                                                  this, service->extensions());
       }
       break;
     }
     default:
       ExtensionProcessManager::Observe(type, source, details);
       break;
   }
 }