No longer start BG mode until a BackgroundContents is loaded

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 198 matching lines @@
   // uninstalls the extension.
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNINSTALLED,
                  content::Source<Profile>(profile));
 }
 
 void BackgroundContentsService::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
-    case chrome::NOTIFICATION_EXTENSIONS_READY:
-      LoadBackgroundContentsFromManifests(
-          content::Source<Profile>(source).ptr());
-      LoadBackgroundContentsFromPrefs(content::Source<Profile>(source).ptr());
+    case chrome::NOTIFICATION_EXTENSIONS_READY: {
+      Profile* profile = content::Source<Profile>(source).ptr();
+      LoadBackgroundContentsFromManifests(profile);
+      LoadBackgroundContentsFromPrefs(profile);
+      SendChangeNotification(profile);
       break;
+    }
     case chrome::NOTIFICATION_BACKGROUND_CONTENTS_DELETED:
       BackgroundContentsShutdown(
           content::Details<BackgroundContents>(details).ptr());
+      SendChangeNotification(content::Source<Profile>(source).ptr());
       break;
     case chrome::NOTIFICATION_BACKGROUND_CONTENTS_CLOSED:
       DCHECK(IsTracked(content::Details<BackgroundContents>(details).ptr()));
       UnregisterBackgroundContents(
           content::Details<BackgroundContents>(details).ptr());
+      // CLOSED is always followed by a DELETED notification so we'll send our
+      // change notification there.
       break;
     case chrome::NOTIFICATION_BACKGROUND_CONTENTS_NAVIGATED: {
       DCHECK(IsTracked(content::Details<BackgroundContents>(details).ptr()));
 
       // Do not register in the pref if the extension has a manifest-specified
       // 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->has_background_page())
           break;
       }
       RegisterBackgroundContents(bgcontents);
+      SendChangeNotification(profile);

[Mihai Parparita -not on Chrome, 2012/05/03 00:54:11]

Why would a navigation cause the list of background contents to change?

[Andrew T Wilson (Slow), 2012/05/03 07:42:56]

It doesn't change the list of background content *objects*, but it *does* change
the list of registered background content URLs (we don't register them until
they have navigated, because that's the first time we actually get the URL).

But, we probably don't need to send a change notification in this case (I added
this originally when IsBackgroundApp() was going to only look at registered
URLs), so I'll remove this.

       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()) {
         // 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->GetBackgroundURL(),
               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: {
       Profile* profile = content::Source<Profile>(source).ptr();
       const Extension* extension = NULL;
       if (type == chrome::NOTIFICATION_BACKGROUND_CONTENTS_TERMINATED) {
         BackgroundContents* bg =
             content::Details<BackgroundContents>(details).ptr();
         std::string extension_id = UTF16ToASCII(
@@ skipping 19 matching lines @@
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_UNLOADED:
       switch (content::Details<UnloadedExtensionInfo>(details)->reason) {
         case extension_misc::UNLOAD_REASON_DISABLE:    // Fall through.
         case extension_misc::UNLOAD_REASON_TERMINATE:  // Fall through.
         case extension_misc::UNLOAD_REASON_UNINSTALL:
           ShutdownAssociatedBackgroundContents(
               ASCIIToUTF16(content::Details<UnloadedExtensionInfo>(details)->
                   extension->id()));
+          SendChangeNotification(content::Source<Profile>(source).ptr());
           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())
             ShutdownAssociatedBackgroundContents(ASCIIToUTF16(extension->id()));
           break;
         }
         default:
           NOTREACHED();
           ShutdownAssociatedBackgroundContents(
               ASCIIToUTF16(content::Details<UnloadedExtensionInfo>(details)->
@@ skipping 39 matching lines @@
       NOTREACHED() << "No extension found for BackgroundContents - id = "
                    << *it;
       // Don't cancel out of our loop, just ignore this BackgroundContents and
       // load the next one.
       continue;
     }
     LoadBackgroundContentsFromDictionary(profile, *it, contents);
   }
 }
 
+void BackgroundContentsService::SendChangeNotification(Profile* profile) {
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_BACKGROUND_CONTENTS_SERVICE_CHANGED,
+      content::Source<Profile>(profile),
+      content::Details<BackgroundContentsService>(this));
+}
+
 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->has_background_page()) {
     LoadBackgroundContents(profile,
                            extension->GetBackgroundURL(),
@@ skipping 114 matching lines @@
   if (pref->GetDictionaryWithoutPathExpansion(UTF16ToUTF8(appid), &current))
     return;
 
   // No entry for this application yet, so add one.
   DictionaryValue* dict = new DictionaryValue();
   dict->SetString(kUrlKey, background_contents->GetURL().spec());
   dict->SetString(kFrameNameKey, contents_map_[appid].frame_name);
   pref->SetWithoutPathExpansion(UTF16ToUTF8(appid), dict);
 }
 
+bool BackgroundContentsService::HasRegisteredBackgroundContents(
+    const string16& app_id) {
+  if (!prefs_)
+    return false;
+  std::string app = UTF16ToUTF8(app_id);
+  const DictionaryValue* contents =
+      prefs_->GetDictionary(prefs::kRegisteredBackgroundContents);
+  // Walk our dictionary looking for any entries with this key.

[Mihai Parparita -not on Chrome, 2012/05/03 00:54:11]

Why not use contents->HasKey(app)?

[Andrew T Wilson (Slow), 2012/05/03 07:42:56]

Ah, good idea. I should've checked DictionaryValue for a useful API first.

+  for (DictionaryValue::key_iterator it = contents->begin_keys();
+       it != contents->end_keys(); ++it) {
+    if (*it == app)
+      return true;
+  }
+  return false;
+}
+
 void BackgroundContentsService::UnregisterBackgroundContents(
     BackgroundContents* background_contents) {
   if (!prefs_)
     return;
   DCHECK(IsTracked(background_contents));
   const string16 appid = GetParentApplicationId(background_contents);
   DictionaryPrefUpdate update(prefs_, prefs::kRegisteredBackgroundContents);
   update.Get()->RemoveWithoutPathExpansion(UTF16ToUTF8(appid), NULL);
 }
 
@@ skipping 53 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);
 }