Adding an experimental app notification API.

chrome/browser/ui/webui/ntp/app_launcher_handler.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/ui/webui/ntp/app_launcher_handler.h"
 
 #include <string>
 #include <vector>
 
 #include "base/auto_reset.h"
@@ skipping 55 matching lines @@
 }  // namespace
 
 AppLauncherHandler::AppLauncherHandler(ExtensionService* extension_service)
     : extensions_service_(extension_service),
       promo_active_(false),
       ignore_changes_(false) {
 }
 
 AppLauncherHandler::~AppLauncherHandler() {}
 
+// Serializes |notification| into a new DictionaryValue which the caller then
+// owns.
+static DictionaryValue* SerializeNotification(
+    const AppNotification& notification) {
+  DictionaryValue* dictionary = new DictionaryValue();
+  dictionary->SetString("title", notification.title);
+  dictionary->SetString("body", notification.body);
+  if (!notification.linkUrl.is_empty()) {
+    dictionary->SetString("linkUrl", notification.linkUrl.spec());
+    dictionary->SetString("linkText", notification.linkText);
+  }
+  return dictionary;
+}
+
 // static
 void AppLauncherHandler::CreateAppInfo(const Extension* extension,
+                                       const AppNotification* notification,
                                        ExtensionPrefs* prefs,
                                        DictionaryValue* value) {
   bool enabled =
       prefs->GetExtensionState(extension->id()) != Extension::DISABLED;
   GURL icon_big =
       ExtensionIconSource::GetIconURL(extension,
                                       Extension::EXTENSION_ICON_LARGE,
                                       ExtensionIconSet::MATCH_EXACTLY,
                                       !enabled);
   GURL icon_small =
@@ skipping 14 matching lines @@
                     Extension::UserMayDisable(extension->location()));
   value->SetString("icon_big", icon_big.spec());
   value->SetString("icon_small", icon_small.spec());
   value->SetInteger("launch_container", extension->launch_container());
   value->SetInteger("launch_type",
       prefs->GetLaunchType(extension->id(),
                                      ExtensionPrefs::LAUNCH_DEFAULT));
   value->SetBoolean("is_component",
       extension->location() == Extension::COMPONENT);
 
+  if (notification)
+    value->Set("notification", SerializeNotification(*notification));
+
   int app_launch_index = prefs->GetAppLaunchIndex(extension->id());
   if (app_launch_index == -1) {
     // Make sure every app has a launch index (some predate the launch index).
     app_launch_index = prefs->GetNextAppLaunchIndex();
     prefs->SetAppLaunchIndex(extension->id(), app_launch_index);
   }
   value->SetInteger("app_launch_index", app_launch_index);
 
   int page_index = prefs->GetPageIndex(extension->id());
   if (page_index >= 0) {
@@ skipping 69 matching lines @@
       NewCallback(this, &AppLauncherHandler::HandlePromoSeen));
 }
 
 void AppLauncherHandler::Observe(NotificationType type,
                                  const NotificationSource& source,
                                  const NotificationDetails& details) {
   if (ignore_changes_)
     return;
 
   switch (type.value) {
+    case NotificationType::APP_NOTIFICATION_STATE_CHANGED: {
+      const std::string& id = *Details<const std::string>(details).ptr();
+      const AppNotification* notification =
+          extensions_service_->app_notification_manager()->GetLast(id);
+      ListValue args;
+      args.Append(new StringValue(id));
+      if (notification)
+        args.Append(SerializeNotification(*notification));
+      web_ui_->CallJavascriptFunction("appsNotificationChangeCallback", args);
+      break;
+    }
     case NotificationType::EXTENSION_LOADED:
     case NotificationType::EXTENSION_UNLOADED:
     case NotificationType::EXTENSION_LAUNCHER_REORDERED:
     // The promo may not load until a couple seconds after the first NTP view,
     // so we listen for the load notification and notify the NTP when ready.
     case NotificationType::WEB_STORE_PROMO_LOADED:
       if (web_ui_->tab_contents())
         HandleGetApps(NULL);
       break;
     case NotificationType::PREF_CHANGED: {
@@ skipping 10 matching lines @@
   }
 }
 
 void AppLauncherHandler::FillAppDictionary(DictionaryValue* dictionary) {
   ListValue* list = new ListValue();
   const ExtensionList* extensions = extensions_service_->extensions();
   ExtensionList::const_iterator it;
   for (it = extensions->begin(); it != extensions->end(); ++it) {
     // Don't include the WebStore.
     // The WebStore launcher gets special treatment in ntp/apps.js.
-    if ((*it)->is_app() &&
-        (*it)->id() != extension_misc::kWebStoreAppId) {
+    const Extension* extension = *it;
+    if (extension->is_app() &&
+        extension->id() != extension_misc::kWebStoreAppId) {
       DictionaryValue* app_info = new DictionaryValue();
-      CreateAppInfo(*it, extensions_service_->extension_prefs(), app_info);
+      AppNotificationManager* notification_manager =
+          extensions_service_->app_notification_manager();
+      CreateAppInfo(extension,
+                    notification_manager->GetLast(extension->id()),
+                    extensions_service_->extension_prefs(),
+                    app_info);
       list->Append(app_info);
     }
   }
 
   extensions = extensions_service_->disabled_extensions();
   for (it = extensions->begin(); it != extensions->end(); ++it) {
     if ((*it)->is_app() &&
         (*it)->id() != extension_misc::kWebStoreAppId) {
       DictionaryValue* app_info = new DictionaryValue();
-      CreateAppInfo(*it, extensions_service_->extension_prefs(), app_info);
+      CreateAppInfo(*it,
+                    NULL,
+                    extensions_service_->extension_prefs(),
+                    app_info);
       list->Append(app_info);
     }
   }
 
   dictionary->Set("apps", list);
 
 #if defined(OS_MACOSX)
   // App windows are not yet implemented on mac.
   dictionary->SetBoolean("disableAppWindowLaunch", true);
   dictionary->SetBoolean("disableCreateAppShortcut", true);
@@ skipping 52 matching lines @@
     ignore_changes_ = false;
     ShownSectionsHandler::SetShownSection(prefs, THUMB);
   }
 
   FillAppDictionary(&dictionary);
   web_ui_->CallJavascriptFunction("getAppsCallback", dictionary);
 
   // First time we get here we set up the observer so that we can tell update
   // the apps as they change.
   if (registrar_.IsEmpty()) {
+    registrar_.Add(this, NotificationType::APP_NOTIFICATION_STATE_CHANGED,
+        NotificationService::AllSources());
     registrar_.Add(this, NotificationType::EXTENSION_LOADED,
         NotificationService::AllSources());
     registrar_.Add(this, NotificationType::EXTENSION_UNLOADED,
         NotificationService::AllSources());
     registrar_.Add(this, NotificationType::EXTENSION_LAUNCHER_REORDERED,
         NotificationService::AllSources());
     registrar_.Add(this, NotificationType::WEB_STORE_PROMO_LOADED,
         NotificationService::AllSources());
   }
   if (pref_change_registrar_.IsEmpty()) {
@@ skipping 325 matching lines @@
 
 void AppLauncherHandler::UninstallDefaultApps() {
   AppsPromo* apps_promo = extensions_service_->apps_promo();
   const ExtensionIdSet& app_ids = apps_promo->old_default_apps();
   for (ExtensionIdSet::const_iterator iter = app_ids.begin();
        iter != app_ids.end(); ++iter) {
     if (extensions_service_->GetExtensionById(*iter, true))
       extensions_service_->UninstallExtension(*iter, false, NULL);
   }
 }