No longer start BG mode until a BackgroundContents is loaded

chrome/browser/background/background_application_list_model.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_application_list_model.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/stl_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/background/background_mode_manager.h"
+#include "chrome/browser/background/background_contents_service.h"
+#include "chrome/browser/background/background_contents_service_factory.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/image_loading_tracker.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_icon_set.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "content/public/browser/notification_details.h"
@@ skipping 48 matching lines @@
 
 namespace {
 void GetServiceApplications(ExtensionService* service,
                             ExtensionList* applications_result) {
   const ExtensionSet* extensions = service->extensions();
 
   for (ExtensionSet::const_iterator cursor = extensions->begin();
        cursor != extensions->end();
        ++cursor) {
     const Extension* extension = *cursor;
-    if (BackgroundApplicationListModel::IsBackgroundApp(*extension))
+    if (BackgroundApplicationListModel::IsBackgroundApp(*extension,
+                                                        service->profile())) {
       applications_result->push_back(extension);
+    }
   }
 
   // Walk the list of terminated extensions also (just because an extension
   // crashed doesn't mean we should ignore it).
   extensions = service->terminated_extensions();
   for (ExtensionSet::const_iterator cursor = extensions->begin();
        cursor != extensions->end();
        ++cursor) {
     const Extension* extension = *cursor;
-    if (BackgroundApplicationListModel::IsBackgroundApp(*extension))
+    if (BackgroundApplicationListModel::IsBackgroundApp(*extension,
+                                                        service->profile())) {
       applications_result->push_back(extension);
+    }
   }
 
   std::string locale = g_browser_process->GetApplicationLocale();
   icu::Locale loc(locale.c_str());
   UErrorCode error = U_ZERO_ERROR;
   scoped_ptr<icu::Collator> collator(icu::Collator::createInstance(loc, error));
   std::sort(applications_result->begin(), applications_result->end(),
        ExtensionNameComparator(collator.get()));
 }
 
@@ skipping 55 matching lines @@
                  content::Source<Profile>(profile));
   registrar_.Add(this,
                  chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::Source<Profile>(profile));
   registrar_.Add(this,
                  chrome::NOTIFICATION_EXTENSIONS_READY,
                  content::Source<Profile>(profile));
   registrar_.Add(this,
                  chrome::NOTIFICATION_EXTENSION_PERMISSIONS_UPDATED,
                  content::Source<Profile>(profile));
+  registrar_.Add(this,
+                 chrome::NOTIFICATION_BACKGROUND_CONTENTS_SERVICE_CHANGED,
+                 content::Source<Profile>(profile));
   ExtensionService* service = profile->GetExtensionService();
   if (service && service->is_ready())
     Update();
 }
 
 void BackgroundApplicationListModel::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void BackgroundApplicationListModel::AssociateApplicationData(
     const Extension* extension) {
-  DCHECK(IsBackgroundApp(*extension));
+  DCHECK(IsBackgroundApp(*extension, profile_));
   Application* application = FindApplication(extension);
   if (!application) {
     // App position is used as a dynamic command and so must be less than any
     // predefined command id.
     if (applications_.size() >= IDC_MinimumLabelValue) {
       LOG(ERROR) << "Background application limit of " << IDC_MinimumLabelValue
                  << " exceeded.  Ignoring.";
       return;
     }
     application = new Application(this, extension);
@@ skipping 51 matching lines @@
        ++cursor, ++position) {
     if (id == cursor->get()->id())
       return position;
   }
   NOTREACHED();
   return -1;
 }
 
 // static
 bool BackgroundApplicationListModel::IsBackgroundApp(
-    const Extension& extension) {
-  return extension.HasAPIPermission(ExtensionAPIPermission::kBackground);
+    const Extension& extension, Profile* profile) {
+  // An extension is a "background app" if it has the "background API"
+  // permission, and meets one of the following criteria:
+  // 1) It is an extension (not a hosted app).
+  // 2) It is a hosted app, and has a background contents registered or in the
+  //    manifest.
+
+  // Not a background app if we don't have the background permission.
+  if (!extension.HasAPIPermission(ExtensionAPIPermission::kBackground))
+    return false;
+
+  // Extensions and packaged apps with background permission are always treated
+  // as background apps.
+  if (!extension.is_hosted_app())
+    return true;
+
+  // Hosted apps with manifest-provided background pages are background apps.
+  if (extension.has_background_page())
+    return true;
+
+  BackgroundContentsService* service =
+      BackgroundContentsServiceFactory::GetForProfile(profile);
+  string16 app_id = ASCIIToUTF16(extension.id());
+  // If we have an active or registered background contents for this app, then
+  // it's a background app. This covers the cases where the app has created its
+  // background contents, but it hasn't navigated yet, or the background
+  // contents crashed and hasn't yet been restarted - in both cases we still
+  // want to treat the app as a background app.
+  if (service->GetAppBackgroundContents(app_id) ||
+      service->HasRegisteredBackgroundContents(app_id)) {
+    return true;
+  }
+
+  // Doesn't meet our criteria, so it's not a background app.
+  return false;
 }
 
 void BackgroundApplicationListModel::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_EXTENSIONS_READY) {
     Update();
     return;
   }
   ExtensionService* service = profile_->GetExtensionService();
   if (!service || !service->is_ready())
     return;
 
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_LOADED:
       OnExtensionLoaded(content::Details<Extension>(details).ptr());
       break;
     case chrome::NOTIFICATION_EXTENSION_UNLOADED:
       OnExtensionUnloaded(
           content::Details<UnloadedExtensionInfo>(details)->extension);
       break;
     case chrome::NOTIFICATION_EXTENSION_PERMISSIONS_UPDATED:
       OnExtensionPermissionsUpdated(
           content::Details<UpdatedExtensionPermissionsInfo>(details)->extension,
           content::Details<UpdatedExtensionPermissionsInfo>(details)->reason,
           content::Details<UpdatedExtensionPermissionsInfo>(details)->
               permissions);
       break;
+    case chrome::NOTIFICATION_BACKGROUND_CONTENTS_SERVICE_CHANGED:
+      Update();
+      break;
     default:
       NOTREACHED() << "Received unexpected notification";
   }
 }
 
 void BackgroundApplicationListModel::SendApplicationDataChangedNotifications(
     const Extension* extension) {
   FOR_EACH_OBSERVER(Observer, observers_, OnApplicationDataChanged(extension,
                                                                    profile_));
 }
 
 void BackgroundApplicationListModel::OnExtensionLoaded(
     const Extension* extension) {
   // We only care about extensions that are background applications
-  if (!IsBackgroundApp(*extension))
+  if (!IsBackgroundApp(*extension, profile_))
     return;
   AssociateApplicationData(extension);
 }
 
 void BackgroundApplicationListModel::OnExtensionUnloaded(
     const Extension* extension) {
-  if (!IsBackgroundApp(*extension))
+  if (!IsBackgroundApp(*extension, profile_))
     return;
   Update();
   DissociateApplicationData(extension);
 }
 
 void BackgroundApplicationListModel::OnExtensionPermissionsUpdated(
     const Extension* extension,
     UpdatedExtensionPermissionsInfo::Reason reason,
     const ExtensionPermissionSet* permissions) {
   if (permissions->HasAPIPermission(ExtensionAPIPermission::kBackground)) {
     switch (reason) {
       case UpdatedExtensionPermissionsInfo::ADDED:
-        DCHECK(IsBackgroundApp(*extension));
+        DCHECK(IsBackgroundApp(*extension, profile_));
         OnExtensionLoaded(extension);
         break;
       case UpdatedExtensionPermissionsInfo::REMOVED:
-        DCHECK(!IsBackgroundApp(*extension));
+        DCHECK(!IsBackgroundApp(*extension, profile_));
         Update();
         DissociateApplicationData(extension);
         break;
       default:
         NOTREACHED();
     }
   }
 }
 
 void BackgroundApplicationListModel::RemoveObserver(Observer* observer) {
@@ skipping 18 matching lines @@
          (*old_cursor)->name() == (*new_cursor)->name() &&
          (*old_cursor)->id() == (*new_cursor)->id()) {
     ++old_cursor;
     ++new_cursor;
   }
   if (old_cursor != extensions_.end() || new_cursor != extensions.end()) {
     extensions_ = extensions;
     FOR_EACH_OBSERVER(Observer, observers_, OnApplicationListChanged(profile_));
   }
 }