Update the web store promo to be clearer and configurable at run-time.

chrome/browser/ui/webui/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/app_launcher_handler.h"
 
 #include <string>
 #include <vector>
 
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
-#include "chrome/browser/extensions/default_apps.h"
+#include "chrome/browser/extensions/apps_promo.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/webui/extension_icon_source.h"
 #include "chrome/browser/ui/webui/shown_sections_handler.h"
 #include "chrome/common/extensions/extension.h"
@@ skipping 111 matching lines @@
     return false;
 
   CHECK(params.size() >= 2);
 
   bool is_promo_active = params.at(1) == "true";
 
   // At this point, the user must have used the app launcher, so we hide the
   // promo if its still displayed.
   if (is_promo_active) {
     DCHECK(profile->GetExtensionService());
-    profile->GetExtensionService()->default_apps()->SetPromoHidden();
+    profile->GetExtensionService()->apps_promo()->ExpireDefaultApps();
   }
 
   if (is_web_store_ping) {
     RecordWebStoreLaunch(is_promo_active);
   }  else {
     CHECK(params.size() == 3);
     RecordAppLaunchByID(is_promo_active, ParseLaunchSource(params.at(2)));
   }
 
   return true;
@@ skipping 14 matching lines @@
   web_ui_->RegisterMessageCallback("uninstallApp",
       NewCallback(this, &AppLauncherHandler::HandleUninstallApp));
   web_ui_->RegisterMessageCallback("hideAppsPromo",
       NewCallback(this, &AppLauncherHandler::HandleHideAppsPromo));
   web_ui_->RegisterMessageCallback("createAppShortcut",
       NewCallback(this, &AppLauncherHandler::HandleCreateAppShortcut));
   web_ui_->RegisterMessageCallback("reorderApps",
       NewCallback(this, &AppLauncherHandler::HandleReorderApps));
   web_ui_->RegisterMessageCallback("setPageIndex",
       NewCallback(this, &AppLauncherHandler::HandleSetPageIndex));
+  web_ui_->RegisterMessageCallback("promoSeen",
+      NewCallback(this, &AppLauncherHandler::HandlePromoSeen));
 }
 
 void AppLauncherHandler::Observe(NotificationType type,
                                  const NotificationSource& source,
                                  const NotificationDetails& details) {
   if (ignore_changes_)
     return;
 
   switch (type.value) {
     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: {
       if (!web_ui_->tab_contents())
         break;
 
       DictionaryValue dictionary;
       FillAppDictionary(&dictionary);
       web_ui_->CallJavascriptFunction("appsPrefChangeCallback", dictionary);
@@ skipping 36 matching lines @@
 #endif
 
 #if defined(OS_CHROMEOS)
   // Making shortcut does not make sense on ChromeOS because it does not have
   // a desktop.
   dictionary->SetBoolean("disableCreateAppShortcut", true);
 #endif
 
   dictionary->SetBoolean(
       "showLauncher",
-      extensions_service_->default_apps()->ShouldShowAppLauncher(
+      extensions_service_->apps_promo()->ShouldShowAppLauncher(
           extensions_service_->GetAppIds()));
 }
 
+void AppLauncherHandler::FillPromoDictionary(DictionaryValue* dictionary) {
+  dictionary->SetString("promoHeader", AppsPromo::GetPromoHeaderText());
+  dictionary->SetString("promoButton", AppsPromo::GetPromoButtonText());
+  dictionary->SetString("promoLink", AppsPromo::GetPromoLink().spec());
+  dictionary->SetString("promoExpire", AppsPromo::GetPromoExpireText());
+}
+
 void AppLauncherHandler::HandleGetApps(const ListValue* args) {
   DictionaryValue dictionary;
 
   // Tell the client whether to show the promo for this view. We don't do this
   // in the case of PREF_CHANGED because:
   //
   // a) At that point in time, depending on the pref that changed, it can look
   //    like the set of apps installed has changed, and we will mark the promo
   //    expired.
   // b) Conceptually, it doesn't really make sense to count a
   //    prefchange-triggered refresh as a promo 'view'.
-  DefaultApps* default_apps = extensions_service_->default_apps();
-  bool promo_just_expired = false;
-  if (default_apps->ShouldShowPromo(extensions_service_->GetAppIds(),
-                                    &promo_just_expired)) {
+  AppsPromo* apps_promo = extensions_service_->apps_promo();
+  PrefService* prefs = web_ui_->GetProfile()->GetPrefs();
+  bool apps_promo_just_expired = false;
+  if (apps_promo->ShouldShowPromo(extensions_service_->GetAppIds(),
+                                  &apps_promo_just_expired)) {
+    // Maximize the apps section on the first promo view.
+    apps_promo->MaximizeAppsIfFirstView();
     dictionary.SetBoolean("showPromo", true);
+    FillPromoDictionary(&dictionary);
     promo_active_ = true;
   } else {
-    if (promo_just_expired) {
-      ignore_changes_ = true;
-      UninstallDefaultApps();
-      ignore_changes_ = false;
-      ShownSectionsHandler::SetShownSection(web_ui_->GetProfile()->GetPrefs(),
-                                            THUMB);
-    }
     dictionary.SetBoolean("showPromo", false);
     promo_active_ = false;
   }
 
+  // If the default apps have just expired (user viewed them too many times with
+  // no interaction), then we uninstall them and focus the recent sites section.
+  if (apps_promo_just_expired) {
+    ignore_changes_ = true;
+    UninstallDefaultApps();
+    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::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()) {
     pref_change_registrar_.Init(
         extensions_service_->extension_prefs()->pref_service());
     pref_change_registrar_.Add(ExtensionPrefs::kExtensionsPref, this);
   }
 }
 
 void AppLauncherHandler::HandleLaunchApp(const ListValue* args) {
   std::string extension_id;
@@ skipping 33 matching lines @@
 
   // If the user pressed special keys when clicking, override the saved
   // preference for launch container.
   bool middle_button = (button == 1.0);
   WindowOpenDisposition disposition =
         disposition_utils::DispositionFromClick(middle_button, alt_key,
                                                 ctrl_key, meta_key, shift_key);
 
   if (extension_id != extension_misc::kWebStoreAppId) {
     RecordAppLaunchByID(promo_active_, launch_bucket);
-    extensions_service_->default_apps()->SetPromoHidden();
+    extensions_service_->apps_promo()->ExpireDefaultApps();
   }
 
   if (disposition == NEW_FOREGROUND_TAB || disposition == NEW_BACKGROUND_TAB) {
     // TODO(jamescook): Proper support for background tabs.
     Browser::OpenApplication(
         profile, extension, extension_misc::LAUNCH_TAB, NULL);
   } else if (disposition == NEW_WINDOW) {
     // Force a new window open.
     Browser::OpenApplication(
             profile, extension, extension_misc::LAUNCH_WINDOW, NULL);
@@ skipping 53 matching lines @@
     return;  // Only one prompt at a time.
 
   extension_id_prompting_ = extension_id;
   GetExtensionUninstallDialog()->ConfirmUninstall(this, extension);
 }
 
 void AppLauncherHandler::HandleHideAppsPromo(const ListValue* args) {
   // If the user has intentionally hidden the promotion, we'll uninstall all the
   // default apps (we know the user hasn't installed any apps on their own at
   // this point, or the promotion wouldn't have been shown).
-  UMA_HISTOGRAM_ENUMERATION(extension_misc::kAppsPromoHistogram,
-                            extension_misc::PROMO_CLOSE,
-                            extension_misc::PROMO_BUCKET_BOUNDARY);
-
-  ShownSectionsHandler::SetShownSection(web_ui_->GetProfile()->GetPrefs(),
-                                        THUMB);
   ignore_changes_ = true;
   UninstallDefaultApps();
-  extensions_service_->default_apps()->SetPromoHidden();
+  extensions_service_->apps_promo()->HidePromo();
   ignore_changes_ = false;
   HandleGetApps(NULL);
 }
 
 void AppLauncherHandler::HandleCreateAppShortcut(const ListValue* args) {
   std::string extension_id;
   if (!args->GetString(0, &extension_id)) {
     NOTREACHED();
     return;
   }
@@ skipping 31 matching lines @@
 void AppLauncherHandler::HandleSetPageIndex(const ListValue* args) {
   std::string extension_id;
   double page_index;
   CHECK(args->GetString(0, &extension_id));
   CHECK(args->GetDouble(1, &page_index));
 
   extensions_service_->extension_prefs()->SetPageIndex(extension_id,
       static_cast<int>(page_index));
 }
 
+void AppLauncherHandler::HandlePromoSeen(const ListValue* args) {
+  UMA_HISTOGRAM_ENUMERATION(extension_misc::kAppsPromoHistogram,
+                            extension_misc::PROMO_SEEN,
+                            extension_misc::PROMO_BUCKET_BOUNDARY);
+}
+
 // static
 void AppLauncherHandler::RecordWebStoreLaunch(bool promo_active) {
   UMA_HISTOGRAM_ENUMERATION(extension_misc::kAppLaunchHistogram,
                             extension_misc::APP_LAUNCH_NTP_WEBSTORE,
                             extension_misc::APP_LAUNCH_BUCKET_BOUNDARY);
 
   if (!promo_active) return;
 
   UMA_HISTOGRAM_ENUMERATION(extension_misc::kAppsPromoHistogram,
                             extension_misc::PROMO_LAUNCH_WEB_STORE,
@@ skipping 112 matching lines @@
 
 ExtensionInstallUI* AppLauncherHandler::GetExtensionInstallUI() {
   if (!extension_install_ui_.get()) {
     extension_install_ui_.reset(
         new ExtensionInstallUI(web_ui_->GetProfile()));
   }
   return extension_install_ui_.get();
 }
 
 void AppLauncherHandler::UninstallDefaultApps() {
-  DefaultApps* default_apps = extensions_service_->default_apps();
-  const ExtensionIdSet& app_ids = default_apps->default_apps();
+  AppsPromo* apps_promo = extensions_service_->apps_promo();
+  const ExtensionIdSet& app_ids = apps_promo->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);
   }
 }