Changes to default apps promo per ui leads:

chrome/browser/dom_ui/app_launcher_handler.cc

 // Copyright (c) 2010 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/dom_ui/app_launcher_handler.h"
 
 #include "app/animation.h"
 #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/app_launched_animation.h"
+#include "chrome/browser/dom_ui/shown_sections_handler.h"
 #include "chrome/browser/extensions/default_apps.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/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 43 matching lines @@
 
   CHECK(params.size() == 2);
 
   return params.at(1) == "true";
 }
 
 }  // namespace
 
 AppLauncherHandler::AppLauncherHandler(ExtensionService* extension_service)
     : extensions_service_(extension_service),
-      promo_active_(false) {
+      promo_active_(false),
+      ignore_changes_(false) {
 }
 
 AppLauncherHandler::~AppLauncherHandler() {}
 
 // static
 void AppLauncherHandler::CreateAppInfo(const Extension* extension,
                                        ExtensionPrefs* extension_prefs,
                                        DictionaryValue* value) {
   value->Clear();
   value->SetString("id", extension->id());
@@ skipping 15 matching lines @@
   int app_launch_index = extension_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 = extension_prefs->GetNextAppLaunchIndex();
     extension_prefs->SetAppLaunchIndex(extension->id(), app_launch_index);
   }
   value->SetInteger("app_launch_index", app_launch_index);
 }
 
 // static
-bool AppLauncherHandler::HandlePing(const std::string& path) {
-  if (path.find(kLaunchWebStorePingURL) != std::string::npos) {
-    RecordWebStoreLaunch(IsPromoActive(path));
-    return true;
-  } else if (path.find(kLaunchAppPingURL) != std::string::npos) {
-    RecordAppLaunch(IsPromoActive(path));
-    return true;
-  }
+bool AppLauncherHandler::HandlePing(Profile* profile, const std::string& path) {
+  bool is_web_store_ping =
+      path.find(kLaunchWebStorePingURL) != std::string::npos;
+  bool is_app_launch_ping =
+      path.find(kLaunchAppPingURL) != std::string::npos;
 
-  return false;
+  if (!is_web_store_ping && !is_app_launch_ping)
+    return false;

[Erik does not do reviews, 2011/01/10 16:48:57]

is there any legit way to hit this?  should this be NOTREACHED?

[Aaron Boodman, 2011/01/10 19:36:19]

Yes, it is legit. We send every request for chrome://newtab/* through this
method. It returns true if it could handle it, false otherwise.

We do this to centralize knowledge about the form of the ping URLs in this
class.

I've added a clarifying comment.

+
+  bool is_promo_active = IsPromoActive(path);
+
+  if (is_web_store_ping)
+    RecordWebStoreLaunch(is_promo_active);
+  else
+    RecordAppLaunch(is_promo_active);
+
+  if (is_promo_active)
+    profile->GetExtensionService()->default_apps()->SetPromoHidden();
+
+  return true;
 }
 
 DOMMessageHandler* AppLauncherHandler::Attach(DOMUI* dom_ui) {
   // TODO(arv): Add initialization code to the Apps store etc.
   return DOMMessageHandler::Attach(dom_ui);
 }
 
 void AppLauncherHandler::RegisterMessages() {
   dom_ui_->RegisterMessageCallback("getApps",
       NewCallback(this, &AppLauncherHandler::HandleGetApps));
   dom_ui_->RegisterMessageCallback("launchApp",
       NewCallback(this, &AppLauncherHandler::HandleLaunchApp));
   dom_ui_->RegisterMessageCallback("setLaunchType",
       NewCallback(this, &AppLauncherHandler::HandleSetLaunchType));
   dom_ui_->RegisterMessageCallback("uninstallApp",
       NewCallback(this, &AppLauncherHandler::HandleUninstallApp));
   dom_ui_->RegisterMessageCallback("hideAppsPromo",
       NewCallback(this, &AppLauncherHandler::HandleHideAppsPromo));
   dom_ui_->RegisterMessageCallback("createAppShortcut",
       NewCallback(this, &AppLauncherHandler::HandleCreateAppShortcut));
 }
 
 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:
       if (dom_ui_->tab_contents())
         HandleGetApps(NULL);
       break;
     case NotificationType::PREF_CHANGED: {
       if (!dom_ui_->tab_contents())
         break;
 
@@ skipping 35 matching lines @@
 #endif
 
   dictionary->SetBoolean(
       "showLauncher",
       extensions_service_->default_apps()->ShouldShowAppLauncher(
           extensions_service_->GetAppIds()));
 }
 
 void AppLauncherHandler::HandleGetApps(const ListValue* args) {
   DictionaryValue dictionary;
-  FillAppDictionary(&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();
-  if (default_apps->ShouldShowPromo(extensions_service_->GetAppIds())) {
+  bool promo_just_expired = false;
+  if (default_apps->ShouldShowPromo(extensions_service_->GetAppIds(),
+                                    &promo_just_expired)) {
     dictionary.SetBoolean("showPromo", true);
-    default_apps->DidShowPromo();
     promo_active_ = true;
   } else {
+    if (promo_just_expired) {
+      ignore_changes_ = true;
+      UninstallDefaultApps();
+      ignore_changes_ = false;
+      ShownSectionsHandler::SetShownSection(dom_ui_->GetProfile()->GetPrefs(),
+                                            THUMB);
+    }
     dictionary.SetBoolean("showPromo", false);
     promo_active_ = false;
   }
 
+  FillAppDictionary(&dictionary);
   dom_ui_->CallJavascriptFunction(L"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());
   }
@@ skipping 46 matching lines @@
   extension_misc::LaunchContainer launch_container =
       extensions_service_->extension_prefs()->GetLaunchContainer(
           extension, ExtensionPrefs::LAUNCH_REGULAR);
 
   TabContents* new_contents = Browser::OpenApplication(
       profile, extension, launch_container, old_contents);
 
   if (new_contents != old_contents && browser->tab_count() > 1)
     browser->CloseTabContents(old_contents);
 
-  if (extension_id != extension_misc::kWebStoreAppId)
+  if (extension_id != extension_misc::kWebStoreAppId) {
     RecordAppLaunch(promo_active_);
+    extensions_service_->default_apps()->SetPromoHidden();
+  }
 }
 
 void AppLauncherHandler::HandleSetLaunchType(const ListValue* args) {
   std::string extension_id;
   int launch_type;
   if (!args->GetString(0, &extension_id) ||
       !ExtractInt(args, 1, &launch_type)) {
     NOTREACHED();
     return;
   }
@@ skipping 22 matching lines @@
 }
 
 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);
 
-  DefaultApps* default_apps = extensions_service_->default_apps();
-  const ExtensionIdSet& app_ids = default_apps->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);
-  }
-
+  ShownSectionsHandler::SetShownSection(dom_ui_->GetProfile()->GetPrefs(),
+                                        THUMB);
+  ignore_changes_ = true;
+  UninstallDefaultApps();
   extensions_service_->default_apps()->SetPromoHidden();
+  ignore_changes_ = false;
+  HandleGetApps(NULL);
 }
 
 void AppLauncherHandler::HandleCreateAppShortcut(const ListValue* args) {
   std::string extension_id;
   if (!args->GetString(0, &extension_id)) {
     NOTREACHED();
     return;
   }
 
   const Extension* extension =
@@ skipping 58 matching lines @@
   // We make this check for the case of minimized windows, unit tests, etc.
   if (platform_util::IsVisible(dom_ui_->tab_contents()->GetNativeView()) &&
       Animation::ShouldRenderRichAnimation()) {
 #if defined(OS_WIN)
     AppLaunchedAnimation::Show(extension, rect);
 #else
     NOTIMPLEMENTED();
 #endif
   }
 }
+
+void AppLauncherHandler::UninstallDefaultApps() {
+  DefaultApps* default_apps = extensions_service_->default_apps();
+  const ExtensionIdSet& app_ids = default_apps->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);
+  }
+}