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);
@@ skipping 23 matching lines @@
           // 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 87 matching lines @@
   // Register the BackgroundContents internally, then send out a notification
   // to external listeners.
   BackgroundContentsOpenedDetails details = {contents,
                                              frame_name,
                                              application_id};
   BackgroundContentsOpened(&details);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_BACKGROUND_CONTENTS_OPENED,
       content::Source<Profile>(profile),
       content::Details<BackgroundContentsOpenedDetails>(&details));
+
+  // A new background contents has been created - notify our listeners.
+  SendChangeNotification(profile);
   return contents;
 }
 
 void BackgroundContentsService::RegisterBackgroundContents(
     BackgroundContents* background_contents) {
   DCHECK(IsTracked(background_contents));
   if (!prefs_)
     return;
 
   // We store the first URL we receive for a given application. If there's
   // already an entry for this application, no need to do anything.
   // TODO(atwilson): Verify that this is the desired behavior based on developer
   // feedback (http://crbug.com/47118).
   DictionaryPrefUpdate update(prefs_, prefs::kRegisteredBackgroundContents);
   DictionaryValue* pref = update.Get();
   const string16& appid = GetParentApplicationId(background_contents);
   DictionaryValue* current;
   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);
+  return contents->HasKey(app);
+}
+
 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);
 }