ntp4: app install improvements

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 56 matching lines @@
       static_cast<extension_misc::AppLaunchBucket>(bucket_num);
   CHECK(bucket < extension_misc::APP_LAUNCH_BUCKET_BOUNDARY);
   return bucket;
 }
 
 }  // namespace
 
 AppLauncherHandler::AppLauncherHandler(ExtensionService* extension_service)
     : extension_service_(extension_service),
       promo_active_(false),
-      ignore_changes_(false) {
+      ignore_changes_(false),
+      attempted_bookmark_app_install_(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);
@@ skipping 165 matching lines @@
       const std::string& id = *Details<const std::string>(details).ptr();
       const AppNotification* notification =
           extension_service_->app_notification_manager()->GetLast(id);
       ListValue args;
       args.Append(new StringValue(id));
       if (notification)
         args.Append(SerializeNotification(*notification));
       web_ui_->CallJavascriptFunction("appNotificationChanged", args);
       break;
     }
-    case chrome::NOTIFICATION_EXTENSION_LOADED:
-    case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
-      const Extension* extension =
-          type == chrome::NOTIFICATION_EXTENSION_LOADED ?
-              Details<const Extension>(details).ptr() :
-              Details<UnloadedExtensionInfo>(details)->extension;
+    case chrome::NOTIFICATION_EXTENSION_LOADED: {
+      const Extension* extension = Details<const Extension>(details).ptr();
       if (!extension->is_app())
+        return;
+
+      if (!NewTabUI::NTP4Enabled()) {
+        HandleGetApps(NULL);
         break;
+      }
 
-      if (NewTabUI::NTP4Enabled()) {
-        scoped_ptr<DictionaryValue> app_info(GetAppInfo(extension));
-        if (app_info.get()) {
-          std::string function =
-              type == chrome::NOTIFICATION_EXTENSION_LOADED ?
-                  "ntp4.appAdded" : "ntp4.appRemoved";
-          web_ui_->CallJavascriptFunction(function, *app_info);
-        }
-      } else if (web_ui_->tab_contents()) {
-        HandleGetApps(NULL);
+      scoped_ptr<DictionaryValue> app_info(GetAppInfo(extension));
+      if (app_info.get()) {
+        ExtensionPrefs* prefs = extension_service_->extension_prefs();
+        scoped_ptr<base::FundamentalValue> highlight(Value::CreateBooleanValue(
+              prefs->IsFromBookmark(extension->id()) &&
+              attempted_bookmark_app_install_));
+        attempted_bookmark_app_install_ = false;
+        web_ui_->CallJavascriptFunction("ntp4.appAdded", *app_info, *highlight);
       }
 
       break;
     }
+    case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
+      const Extension* extension =
+          Details<UnloadedExtensionInfo>(details)->extension;
+      if (!extension->is_app())
+        return;
+
+      if (!NewTabUI::NTP4Enabled()) {
+        HandleGetApps(NULL);
+        break;
+      }
+
+      scoped_ptr<DictionaryValue> app_info(GetAppInfo(extension));
+      if (app_info.get())
+        web_ui_->CallJavascriptFunction("ntp4.appRemoved", *app_info);
+      break;
+    }
     case chrome::NOTIFICATION_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 chrome::NOTIFICATION_WEB_STORE_PROMO_LOADED:
       if (web_ui_->tab_contents())
         HandleGetApps(NULL);
       break;
     case chrome::NOTIFICATION_PREF_CHANGED: {
       if (!web_ui_->tab_contents())
         break;
       // Handle app page renames.
       std::string* pref_name = Details<std::string>(details).ptr();
       if (*pref_name == prefs::kNTPAppPageNames) {
         // TODO(estade): this doesn't need to regenerate the entire page.
         HandleGetApps(NULL);
       } else {
         // Default prefs change handling.
         DictionaryValue dictionary;
         FillAppDictionary(&dictionary);
         web_ui_->CallJavascriptFunction("appsPrefChangeCallback", dictionary);
       }
       break;
     }
+    case chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR: {
+      attempted_bookmark_app_install_ = false;
+      break;
+    }
     default:
       NOTREACHED();
   }
 }
 
 void AppLauncherHandler::FillAppDictionary(DictionaryValue* dictionary) {
   ListValue* list = new ListValue();
   const ExtensionList* extensions = extension_service_->extensions();
   ExtensionList::const_iterator it;
   for (it = extensions->begin(); it != extensions->end(); ++it) {
@@ skipping 120 matching lines @@
     registrar_.Add(this, chrome::NOTIFICATION_APP_NOTIFICATION_STATE_CHANGED,
         NotificationService::AllSources());
     registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOADED,
         NotificationService::AllSources());
     registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
         NotificationService::AllSources());
     registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LAUNCHER_REORDERED,
         NotificationService::AllSources());
     registrar_.Add(this, chrome::NOTIFICATION_WEB_STORE_PROMO_LOADED,
         NotificationService::AllSources());
+    registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_INSTALL_ERROR,
+        NotificationService::AllSources());
   }
   if (pref_change_registrar_.IsEmpty()) {
     pref_change_registrar_.Init(
         extension_service_->extension_prefs()->pref_service());
     pref_change_registrar_.Add(ExtensionPrefs::kExtensionsPref, this);
     pref_change_registrar_.Add(prefs::kNTPAppPageNames, this);
   }
 }
 
 void AppLauncherHandler::HandleLaunchApp(const ListValue* args) {
@@ skipping 291 matching lines @@
     web_app->icons[0].width = web_app->icons[0].data.width();
     web_app->icons[0].height = web_app->icons[0].data.height();
   } else {
     web_app->icons.clear();
   }
 
   scoped_refptr<CrxInstaller> installer(
       extension_service_->MakeCrxInstaller(NULL));
   installer->set_page_index(install_info->page_index);
   installer->InstallWebApp(*web_app);
+  attempted_bookmark_app_install_ = true;
 }
 
 // static
 void AppLauncherHandler::RegisterUserPrefs(PrefService* pref_service) {
   // TODO(csilv): We will want this to be a syncable preference instead.
   pref_service->RegisterListPref(prefs::kNTPAppPageNames,
                                  PrefService::UNSYNCABLE_PREF);
 }
 
 // statiic
@@ skipping 147 matching lines @@
 
 void AppLauncherHandler::UninstallDefaultApps() {
   AppsPromo* apps_promo = extension_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 (extension_service_->GetExtensionById(*iter, true))
       extension_service_->UninstallExtension(*iter, false, NULL);
   }
 }