Introduce background.scripts feature for extension manifests.

chrome/browser/background/background_contents_service.cc

 // Copyright (c) 2011 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/string_util.h"
@@ skipping 221 matching lines @@
       // background page.
       BackgroundContents* bgcontents =
           content::Details<BackgroundContents>(details).ptr();
       Profile* profile = content::Source<Profile>(source).ptr();
       const string16& appid = GetParentApplicationId(bgcontents);
       ExtensionService* extension_service = profile->GetExtensionService();
       // extension_service can be NULL when running tests.
       if (extension_service) {
         const Extension* extension =
             extension_service->GetExtensionById(UTF16ToUTF8(appid), false);
-        if (extension && extension->background_url().is_valid())
+        if (extension && extension->has_background_page())
           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->background_url().is_valid()) {
+          extension->has_background_page()) {
         // 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 = profile->GetExtensionService();
         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->background_url(),
+          LoadBackgroundContents(profile, extension->GetBackgroundURL(),
               ASCIIToUTF16("background"), UTF8ToUTF16(extension->id()));
         }
       }
 
       // Remove any "This extension has crashed" balloons.
       ScheduleCloseBalloon(extension->id());
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_PROCESS_TERMINATED:
     case chrome::NOTIFICATION_BACKGROUND_CONTENTS_TERMINATED: {
@@ skipping 33 matching lines @@
               ASCIIToUTF16(content::Details<UnloadedExtensionInfo>(details)->
                   extension->id()));
           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.
           const Extension* extension =
               content::Details<UnloadedExtensionInfo>(details)->extension;
-          if (extension->background_url().is_valid())
+          if (extension->has_background_page())
             ShutdownAssociatedBackgroundContents(ASCIIToUTF16(extension->id()));
           break;
         }
         default:
           NOTREACHED();
           ShutdownAssociatedBackgroundContents(
               ASCIIToUTF16(content::Details<UnloadedExtensionInfo>(details)->
                   extension->id()));
           break;
       }
@@ skipping 43 matching lines @@
   }
 }
 
 void BackgroundContentsService::LoadBackgroundContentsForExtension(
     Profile* profile,
     const std::string& extension_id) {
   // First look if the manifest specifies a background page.
   const Extension* extension =
       profile->GetExtensionService()->GetExtensionById(extension_id, false);
   DCHECK(!extension || extension->is_hosted_app());
-  if (extension && extension->background_url().is_valid()) {
+  if (extension && extension->has_background_page()) {
     LoadBackgroundContents(profile,
-                           extension->background_url(),
+                           extension->GetBackgroundURL(),
                            ASCIIToUTF16("background"),
                            UTF8ToUTF16(extension->id()));
     return;
   }
 
   // Now look in the prefs.
   if (!prefs_)
     return;
   const DictionaryValue* contents =
       prefs_->GetDictionary(prefs::kRegisteredBackgroundContents);
@@ skipping 24 matching lines @@
                          UTF8ToUTF16(extension_id));
 }
 
 void BackgroundContentsService::LoadBackgroundContentsFromManifests(
     Profile* profile) {
   const ExtensionSet* extensions =
       profile->GetExtensionService()->extensions();
   ExtensionSet::const_iterator iter = extensions->begin();
   for (; iter != extensions->end(); ++iter) {
     const Extension* extension = *iter;
-    if (extension->is_hosted_app() &&
-        extension->background_url().is_valid()) {
+    if (extension->is_hosted_app() && extension->has_background_page()) {
       LoadBackgroundContents(profile,
-                             extension->background_url(),
+                             extension->GetBackgroundURL(),
                              ASCIIToUTF16("background"),
                              UTF8ToUTF16(extension->id()));
     }
   }
 }
 
 void BackgroundContentsService::LoadBackgroundContents(
     Profile* profile,
     const GURL& url,
     const string16& frame_name,
@@ skipping 130 matching lines @@
     WebContents* new_contents,
     WindowOpenDisposition disposition,
     const gfx::Rect& initial_pos,
     bool user_gesture) {
   Browser* browser = BrowserList::GetLastActiveWithProfile(
       Profile::FromBrowserContext(new_contents->GetBrowserContext()));
   if (!browser)
     return;
   browser->AddWebContents(new_contents, disposition, initial_pos, user_gesture);
 }