Manifest handler for all keys background-related.

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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
@@ skipping 10 matching lines @@
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/notifications/notification_ui_manager.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.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_tabstrip.h"
 #include "chrome/browser/ui/host_desktop.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_constants.h"
 #include "chrome/common/extensions/extension_icon_set.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "grit/generated_resources.h"
 #include "ipc/ipc_message.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::SiteInstance;
 using content::WebContents;
+using extensions::BackgroundInfo;
 using extensions::Extension;
 using extensions::UnloadedExtensionInfo;
 
 namespace {
 
 const char kNotificationPrefix[] = "app.background.crashed.";
 
 void CloseBalloon(const std::string id) {
   g_browser_process->notification_ui_manager()->CancelById(id);
 }
@@ skipping 203 matching lines @@
       BackgroundContents* bgcontents =
           content::Details<BackgroundContents>(details).ptr();
       Profile* profile = content::Source<Profile>(source).ptr();
       const string16& appid = GetParentApplicationId(bgcontents);
       ExtensionService* extension_service =
           extensions::ExtensionSystem::Get(profile)->extension_service();
       // extension_service can be NULL when running tests.
       if (extension_service) {
         const Extension* extension =
             extension_service->GetExtensionById(UTF16ToUTF8(appid), false);
-        if (extension && extension->has_background_page())
+        if (extension && BackgroundInfo::HasBackgroundPage(extension))
           break;
       }
       RegisterBackgroundContents(bgcontents);
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_LOADED: {
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
       Profile* profile = content::Source<Profile>(source).ptr();
       if (extension->is_hosted_app() &&
-          extension->has_background_page()) {
+          BackgroundInfo::HasBackgroundPage(extension)) {
         // If there is a background page specified in the manifest for a hosted
         // app, then blow away registered urls in the pref.
         ShutdownAssociatedBackgroundContents(ASCIIToUTF16(extension->id()));
 
         ExtensionService* service =
             extensions::ExtensionSystem::Get(profile)->extension_service();
         if (service && service->is_ready()) {
           // 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, extension->GetBackgroundURL(),
-              ASCIIToUTF16("background"), UTF8ToUTF16(extension->id()));
+          LoadBackgroundContents(profile,
+                                 BackgroundInfo::GetBackgroundURL(extension),
+                                 ASCIIToUTF16("background"),
+                                 UTF8ToUTF16(extension->id()));
         }
       }
 
       // Remove any "This extension has crashed" balloons.
       ScheduleCloseBalloon(extension->id());
       SendChangeNotification(profile);
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED:
     case chrome::NOTIFICATION_BACKGROUND_CONTENTS_TERMINATED: {
@@ skipping 38 matching lines @@
           break;
         case extension_misc::UNLOAD_REASON_UPDATE: {
           // If there is a manifest specified background page, then shut it down
           // here, since if the updated extension still has the background page,
           // then it will be loaded from LOADED callback. Otherwise, leave
           // BackgroundContents in place.
           // We don't call SendChangeNotification here - it will be generated
           // from the LOADED callback.
           const Extension* extension =
               content::Details<UnloadedExtensionInfo>(details)->extension;
-          if (extension->has_background_page())
+          if (BackgroundInfo::HasBackgroundPage(extension))
             ShutdownAssociatedBackgroundContents(ASCIIToUTF16(extension->id()));
           break;
         }
         default:
           NOTREACHED();
           ShutdownAssociatedBackgroundContents(
               ASCIIToUTF16(content::Details<UnloadedExtensionInfo>(details)->
                   extension->id()));
           break;
       }
@@ skipping 53 matching lines @@
 }
 
 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 && extension->has_background_page()) {
+  if (extension && BackgroundInfo::HasBackgroundPage(extension)) {
     LoadBackgroundContents(profile,
-                           extension->GetBackgroundURL(),
+                           BackgroundInfo::GetBackgroundURL(extension),
                            ASCIIToUTF16("background"),
                            UTF8ToUTF16(extension->id()));
     return;
   }
 
   // Now look in the prefs.
   if (!prefs_)
     return;
   const DictionaryValue* contents =
       prefs_->GetDictionary(prefs::kRegisteredBackgroundContents);
@@ skipping 25 matching lines @@
                          UTF8ToUTF16(extension_id));
 }
 
 void BackgroundContentsService::LoadBackgroundContentsFromManifests(
     Profile* profile) {
   const ExtensionSet* extensions = extensions::ExtensionSystem::Get(profile)->
       extension_service()->extensions();
   ExtensionSet::const_iterator iter = extensions->begin();
   for (; iter != extensions->end(); ++iter) {
     const Extension* extension = *iter;
-    if (extension->is_hosted_app() && extension->has_background_page()) {
+    if (extension->is_hosted_app() &&
+        BackgroundInfo::HasBackgroundPage(extension)) {
       LoadBackgroundContents(profile,
-                             extension->GetBackgroundURL(),
+                             BackgroundInfo::GetBackgroundURL(extension),
                              ASCIIToUTF16("background"),
                              UTF8ToUTF16(extension->id()));
     }
   }
 }
 
 void BackgroundContentsService::LoadBackgroundContents(
     Profile* profile,
     const GURL& url,
     const string16& frame_name,
@@ skipping 146 matching lines @@
     bool user_gesture,
     bool* was_blocked) {
   Browser* browser = chrome::FindLastActiveWithProfile(
       Profile::FromBrowserContext(new_contents->GetBrowserContext()),
       chrome::GetActiveDesktop());
   if (browser) {
     chrome::AddWebContents(browser, NULL, new_contents, disposition,
                            initial_pos, user_gesture, was_blocked);
   }
 }