Append parameters to webstore URL to indicate launch source.

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 35 matching lines @@
 #include "grit/browser_resources.h"
 #include "grit/generated_resources.h"
 #include "net/base/escape.h"
 #include "ui/base/animation/animation.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "webkit/glue/window_open_disposition.h"
 
 namespace {
 
-// The URL prefixes used by the NTP to signal when the web store or an app
-// has launched so we can record the proper histogram.
-const char* kPingLaunchAppByID = "record-app-launch-by-id";
-const char* kPingLaunchWebStore = "record-webstore-launch";
-const char* kPingLaunchAppByURL = "record-app-launch-by-url";
-
 const UnescapeRule::Type kUnescapeRules =
     UnescapeRule::NORMAL | UnescapeRule::URL_SPECIAL_CHARS;
 
 extension_misc::AppLaunchBucket ParseLaunchSource(
     const std::string& launch_source) {
   int bucket_num = extension_misc::APP_LAUNCH_BUCKET_INVALID;
   base::StringToInt(launch_source, &bucket_num);
   extension_misc::AppLaunchBucket bucket =
       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),
       attempted_bookmark_app_install_(false),
       has_loaded_apps_(false) {
 }
 
 AppLauncherHandler::~AppLauncherHandler() {}
 
 // Serializes |notification| into a new DictionaryValue which the caller then
 // owns.
 static DictionaryValue* SerializeNotification(
@@ skipping 93 matching lines @@
   if (page_index < 0) {
     // Make sure every app has a page index (some predate the page index).
     // The webstore app should be on the first page.
     page_index = extension->id() == extension_misc::kWebStoreAppId ?
         0 : prefs->GetNaturalAppPageIndex();
     prefs->SetPageIndex(extension->id(), page_index);
   }
   value->SetInteger("page_index", page_index);
 }
 
-// TODO(estade): remove this. We record app launches via js calls rather than
-// pings for ntp4.
-// static
-bool AppLauncherHandler::HandlePing(Profile* profile, const std::string& path) {
-  std::vector<std::string> params;
-  base::SplitString(path, '+', &params);
-
-  // Check if the user launched an app from the most visited or recently
-  // closed sections.
-  if (kPingLaunchAppByURL == params.at(0)) {
-    CHECK(params.size() == 3);
-    RecordAppLaunchByURL(
-        profile, params.at(1), ParseLaunchSource(params.at(2)));
-    return true;
-  }
-
-  bool is_web_store_ping = kPingLaunchWebStore == params.at(0);
-  bool is_app_launch_ping = kPingLaunchAppByID == params.at(0);
-
-  if (!is_web_store_ping && !is_app_launch_ping)
-    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()->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;
-}
-
 WebUIMessageHandler* AppLauncherHandler::Attach(WebUI* web_ui) {
   registrar_.Add(this, chrome::NOTIFICATION_APP_INSTALLED_TO_NTP,
       content::Source<TabContents>(web_ui->tab_contents()));
   return WebUIMessageHandler::Attach(web_ui);
 }
 
 void AppLauncherHandler::RegisterMessages() {
   web_ui_->RegisterMessageCallback("getApps",
       base::Bind(&AppLauncherHandler::HandleGetApps,
                  base::Unretained(this)));
@@ skipping 261 matching lines @@
   //    expired.
   // b) Conceptually, it doesn't really make sense to count a
   //    prefchange-triggered refresh as a promo 'view'.
   AppsPromo* apps_promo = extension_service_->apps_promo();
   Profile* profile = Profile::FromWebUI(web_ui_);
   bool apps_promo_just_expired = false;
   if (apps_promo->ShouldShowPromo(extension_service_->GetAppIds(),
                                   &apps_promo_just_expired)) {
     dictionary.SetBoolean("showPromo", true);
     FillPromoDictionary(&dictionary);
-    promo_active_ = true;
   } else {
     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;
   }
 
@@ skipping 24 matching lines @@
     registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_LOAD_ERROR,
         content::Source<Profile>(profile));
   }
 
   has_loaded_apps_ = true;
 }
 
 void AppLauncherHandler::HandleLaunchApp(const ListValue* args) {
   std::string extension_id;
   double source = -1.0;
+  std::string url;
   bool alt_key = false;
   bool ctrl_key = false;
   bool meta_key = false;
   bool shift_key = false;
   double button = 0.0;
 
   CHECK(args->GetString(0, &extension_id));
   CHECK(args->GetDouble(1, &source));
-  if (args->GetSize() > 2) {
-    CHECK(args->GetBoolean(2, &alt_key));
-    CHECK(args->GetBoolean(3, &ctrl_key));
-    CHECK(args->GetBoolean(4, &meta_key));
-    CHECK(args->GetBoolean(5, &shift_key));
-    CHECK(args->GetDouble(6, &button));
+  if (args->GetSize() > 2)
+    CHECK(args->GetString(2, &url));
+  if (args->GetSize() > 3) {
+    CHECK(args->GetBoolean(3, &alt_key));
+    CHECK(args->GetBoolean(4, &ctrl_key));
+    CHECK(args->GetBoolean(5, &meta_key));
+    CHECK(args->GetBoolean(6, &shift_key));
+    CHECK(args->GetDouble(7, &button));
   }
 
   extension_misc::AppLaunchBucket launch_bucket =
       static_cast<extension_misc::AppLaunchBucket>(
           static_cast<int>(source));
   CHECK(launch_bucket >= 0 &&
         launch_bucket < extension_misc::APP_LAUNCH_BUCKET_BOUNDARY);
 
   const Extension* extension =
       extension_service_->GetExtensionById(extension_id, false);
 
   // Prompt the user to re-enable the application if disabled.
   if (!extension) {
     PromptToEnableApp(extension_id);
     return;
   }
 
   Profile* profile = extension_service_->profile();
 
   // 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);
+    RecordAppLaunchByID(launch_bucket);
     extension_service_->apps_promo()->ExpireDefaultApps();
   } else if (NewTabUI::NTP4Enabled()) {
-    RecordWebStoreLaunch(promo_active_);
+    RecordWebStoreLaunch(url.find("chrome-ntp-promo") != std::string::npos);
   }
 
   if (disposition == NEW_FOREGROUND_TAB || disposition == NEW_BACKGROUND_TAB) {
     // TODO(jamescook): Proper support for background tabs.
     Browser::OpenApplication(
-        profile, extension, extension_misc::LAUNCH_TAB, disposition);
+        profile, extension, extension_misc::LAUNCH_TAB, GURL(url), disposition);
   } else if (disposition == NEW_WINDOW) {
     // Force a new window open.
     Browser::OpenApplication(
-            profile, extension, extension_misc::LAUNCH_WINDOW, disposition);
+        profile, extension, extension_misc::LAUNCH_WINDOW, GURL(url),
+        disposition);
   } else {
     // Look at preference to find the right launch container.  If no preference
     // is set, launch as a regular tab.
     extension_misc::LaunchContainer launch_container =
         extension_service_->extension_prefs()->GetLaunchContainer(
             extension, ExtensionPrefs::LAUNCH_REGULAR);
 
     // To give a more "launchy" experience when using the NTP launcher, we close
     // it automatically.
     Browser* browser = BrowserList::GetLastActiveWithProfile(profile);
     TabContents* old_contents = NULL;
     if (browser)
       old_contents = browser->GetSelectedTabContents();
 
     TabContents* new_contents = Browser::OpenApplication(
-        profile, extension, launch_container,
+        profile, extension, launch_container, GURL(url),
         old_contents ? CURRENT_TAB : NEW_FOREGROUND_TAB);
 
     // This will also destroy the handler, so do not perform any actions after.
     if (new_contents != old_contents && browser && browser->tab_count() > 1)
       browser->CloseTabContents(old_contents);
   }
 }
 
 void AppLauncherHandler::HandleSetLaunchType(const ListValue* args) {
   std::string extension_id;
@@ skipping 257 matching lines @@
 
   if (!promo_active) return;
 
   UMA_HISTOGRAM_ENUMERATION(extension_misc::kAppsPromoHistogram,
                             extension_misc::PROMO_LAUNCH_WEB_STORE,
                             extension_misc::PROMO_BUCKET_BOUNDARY);
 }
 
 // static
 void AppLauncherHandler::RecordAppLaunchByID(
-    bool promo_active, extension_misc::AppLaunchBucket bucket) {
+    extension_misc::AppLaunchBucket bucket) {
   CHECK(bucket != extension_misc::APP_LAUNCH_BUCKET_INVALID);
 
   UMA_HISTOGRAM_ENUMERATION(extension_misc::kAppLaunchHistogram, bucket,
                             extension_misc::APP_LAUNCH_BUCKET_BOUNDARY);
-
-  if (!promo_active) return;
-
-  UMA_HISTOGRAM_ENUMERATION(extension_misc::kAppsPromoHistogram,
-                            extension_misc::PROMO_LAUNCH_APP,
-                            extension_misc::PROMO_BUCKET_BOUNDARY);
 }
 
 // static
 void AppLauncherHandler::RecordAppLaunchByURL(
     Profile* profile,
     std::string escaped_url,
     extension_misc::AppLaunchBucket bucket) {
   CHECK(bucket != extension_misc::APP_LAUNCH_BUCKET_INVALID);
 
   GURL url(net::UnescapeURLComponent(escaped_url, kUnescapeRules));
@@ skipping 115 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);
   }
 }