Add a histogram for tracking web store promo

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_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/app_launched_animation.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/extensions/default_apps.h"
 #include "chrome/browser/extensions/extension_prefs.h"
 #include "chrome/browser/extensions/extensions_service.h"
@@ skipping 31 matching lines @@
   GURL url = extension->GetIconURL(icon, ExtensionIconSet::MATCH_EXACTLY);
   if (!url.is_empty())
     return url.spec();
   else
     return default_val;
 }
 
 }  // namespace
 
 AppLauncherHandler::AppLauncherHandler(ExtensionsService* extension_service)
-    : extensions_service_(extension_service) {
+    : extensions_service_(extension_service),
+      promo_active_(false) {
 }
 
 AppLauncherHandler::~AppLauncherHandler() {}
 
 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("recordWebStoreLaunch",
+      NewCallback(this, &AppLauncherHandler::HandleRecordWebStoreLaunch));
+  dom_ui_->RegisterMessageCallback("recordAppLaunch",
+      NewCallback(this, &AppLauncherHandler::HandleRecordAppLaunch));
 }
 
 void AppLauncherHandler::Observe(NotificationType type,
                                  const NotificationSource& source,
                                  const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::EXTENSION_LOADED:
     case NotificationType::EXTENSION_UNLOADED:
       if (dom_ui_->tab_contents())
         HandleGetApps(NULL);
@@ skipping 53 matching lines @@
       CreateAppInfo(*it, extensions_service_->extension_prefs(), app_info);
       list->Append(app_info);
     }
   }
   dictionary->Set("apps", list);
 
   DefaultApps* default_apps = extensions_service_->default_apps();
   if (default_apps->ShouldShowPromo(extensions_service_->GetAppIds())) {
     dictionary->SetBoolean("showPromo", true);
     default_apps->DidShowPromo();
+    promo_active_ = true;
   } else {
     dictionary->SetBoolean("showPromo", false);
+    promo_active_ = false;
   }
 
   bool showLauncher =
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableAppLauncher);
   dictionary->SetBoolean("showLauncher", showLauncher);
 }
 
 void AppLauncherHandler::HandleGetApps(const ListValue* args) {
   DictionaryValue dictionary;
   FillAppDictionary(&dictionary);
@@ skipping 99 matching lines @@
     return;  // Only one prompt at a time.
 
   extension_id_prompting_ = extension_id;
   GetExtensionInstallUI()->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("Extensions.AppsPromo",
+                            extension_misc::CLOSE_PROMO,
+                            extension_misc::MAX);

[Erik does not do reviews, 2010/11/10 23:29:51]

given that you're using a common namespace for these, "MAX" (and perhaps the
rest of the enum) should have some unique prefix on it

   DefaultApps* default_apps = extensions_service_->default_apps();
   const ExtensionIdSet* app_ids = default_apps->GetDefaultApps();
   DCHECK(*app_ids == extensions_service_->GetAppIds());
 
   for (ExtensionIdSet::const_iterator iter = app_ids->begin();
        iter != app_ids->end(); ++iter) {
     if (extensions_service_->GetExtensionById(*iter, true))
       extensions_service_->UninstallExtension(*iter, false);
   }
 
   extensions_service_->default_apps()->SetPromoHidden();
 }
 
+void AppLauncherHandler::HandleRecordWebStoreLaunch(const ListValue* args) {
+  if (promo_active_) {
+    UMA_HISTOGRAM_ENUMERATION("Extensions.AppsPromo",
+                              extension_misc::LAUNCH_WEB_STORE,
+                              extension_misc::MAX);
+  }
+}
+
+void AppLauncherHandler::HandleRecordAppLaunch(const ListValue* args) {
+  if (promo_active_) {
+    UMA_HISTOGRAM_ENUMERATION("Extensions.AppsPromo",
+                              extension_misc::LAUNCH_APP,
+                              extension_misc::MAX);
+
+    // If we're launching the web store application, then we may have to bump

[Erik does not do reviews, 2010/11/10 23:29:51]

if that's the case, then we shouldn't bump LAUNCH_APP, right?

+    // the web store launch histogram.
+    std::string extension_id;
+
+    if (!args->GetString(0, &extension_id)) {
+      NOTREACHED();
+      return;
+    }
+    if (extension_id == extension_misc::kWebStoreAppId ||
+        extension_id == extension_misc::kNTPWebStoreAppId)
+      HandleRecordWebStoreLaunch(args);
+  }
+}
+
 ExtensionInstallUI* AppLauncherHandler::GetExtensionInstallUI() {
   if (!install_ui_.get())
     install_ui_.reset(new ExtensionInstallUI(dom_ui_->GetProfile()));
   return install_ui_.get();
 }
 
 void AppLauncherHandler::InstallUIProceed() {
   DCHECK(!extension_id_prompting_.empty());
 
   // The extension can be uninstalled in another window while the UI was
   // showing. Do nothing in that case.
   const Extension* extension =
       extensions_service_->GetExtensionById(extension_id_prompting_, true);
   if (!extension)
     return;
 
   extensions_service_->UninstallExtension(extension_id_prompting_,
                                           false /* external_uninstall */);
   extension_id_prompting_ = "";
 }
 
 void AppLauncherHandler::InstallUIAbort() {
   extension_id_prompting_ = "";
 }