chrome/browser/ui/app_list/app_list_service.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/app_list/app_list_service.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/metrics/histogram.h"
   9 #include "base/prefs/pref_registry_simple.h"
  10 #include "base/process/process_info.h"
  11 #include "base/strings/string_number_conversions.h"
  12 #include "base/time/time.h"
  13 #include "chrome/common/chrome_switches.h"
  14 #include "chrome/common/pref_names.h"
  15
  16 namespace {
  17
  18 enum StartupType {
  19   COLD_START,
  20   WARM_START,
  21   WARM_START_FAST,
  22 };
  23
  24 // For when an app list show request is received via CommandLine. Indicates
  25 // whether the Profile the app list was previously showing was the SAME, OTHER
  26 // or NONE with respect to the new Profile to show.
  27 enum ProfileLoadState {
  28   PROFILE_LOADED_SAME,
  29   PROFILE_LOADED_OTHER,
  30   PROFILE_LOADED_NONE,
  31 };
  32
  33 base::Time GetOriginalProcessStartTime(const CommandLine& command_line) {
  34   if (command_line.HasSwitch(switches::kOriginalProcessStartTime)) {
  35     std::string start_time_string =
  36         command_line.GetSwitchValueASCII(switches::kOriginalProcessStartTime);
  37     int64 remote_start_time;
  38     base::StringToInt64(start_time_string, &remote_start_time);
  39     return base::Time::FromInternalValue(remote_start_time);
  40   }
  41
  42 // base::CurrentProcessInfo::CreationTime() is only defined on some
  43 // platforms.
  44 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX)
  45   return base::CurrentProcessInfo::CreationTime();
  46 #else
  47   return base::Time();
  48 #endif
  49 }
  50
  51 StartupType GetStartupType(const CommandLine& command_line) {
  52   // The presence of kOriginalProcessStartTime implies that another process
  53   // has sent us its command line to handle, ie: we are already running.
  54   if (command_line.HasSwitch(switches::kOriginalProcessStartTime)) {
  55     return command_line.HasSwitch(switches::kFastStart) ?
  56         WARM_START_FAST : WARM_START;
  57   }
  58   return COLD_START;
  59 }
  60
  61 // The time the process that caused the app list to be shown started. This isn't
  62 // necessarily the currently executing process as we may be processing a command
  63 // line given to a short-lived Chrome instance.
  64 int64 g_original_process_start_time;
  65
  66 // The type of startup the the current app list show has gone through.
  67 StartupType g_app_show_startup_type;
  68
  69 // The state of the active app list profile at the most recent launch.
  70 ProfileLoadState g_profile_load_state;
  71
  72 void RecordFirstPaintTiming() {
  73   base::Time start_time(
  74       base::Time::FromInternalValue(g_original_process_start_time));
  75   base::TimeDelta elapsed = base::Time::Now() - start_time;
  76   switch (g_app_show_startup_type) {
  77     case COLD_START:
  78       DCHECK_EQ(PROFILE_LOADED_NONE, g_profile_load_state);
  79       UMA_HISTOGRAM_LONG_TIMES("Startup.AppListFirstPaintColdStart", elapsed);
  80       break;
  81     case WARM_START:
  82       // For warm starts, only record showing the same profile. "NONE" should
  83       // only occur in the first 30 seconds after startup. "OTHER" only occurs
  84       // for multi-profile cases. In these cases, timings are also affected by
  85       // whether or not a profile has been loaded from disk, which makes the
  86       // profile load asynchronous and skews results unpredictably.
  87       if (g_profile_load_state == PROFILE_LOADED_SAME)
  88         UMA_HISTOGRAM_LONG_TIMES("Startup.AppListFirstPaintWarmStart", elapsed);
  89       break;
  90     case WARM_START_FAST:
  91       if (g_profile_load_state == PROFILE_LOADED_SAME) {
  92         UMA_HISTOGRAM_LONG_TIMES("Startup.AppListFirstPaintWarmStartFast",
  93                                  elapsed);
  94       }
  95       break;
  96   }
  97 }
  98
  99 void RecordStartupInfo(AppListService* service,
 100                        const CommandLine& command_line,
 101                        Profile* launch_profile) {
 102   base::Time start_time = GetOriginalProcessStartTime(command_line);
 103   if (start_time.is_null())
 104     return;
 105
 106   base::TimeDelta elapsed = base::Time::Now() - start_time;
 107   StartupType startup_type = GetStartupType(command_line);
 108   switch (startup_type) {
 109     case COLD_START:
 110       UMA_HISTOGRAM_LONG_TIMES("Startup.ShowAppListColdStart", elapsed);
 111       break;
 112     case WARM_START:
 113       UMA_HISTOGRAM_LONG_TIMES("Startup.ShowAppListWarmStart", elapsed);
 114       break;
 115     case WARM_START_FAST:
 116       UMA_HISTOGRAM_LONG_TIMES("Startup.ShowAppListWarmStartFast", elapsed);
 117       break;
 118   }
 119
 120   g_original_process_start_time = start_time.ToInternalValue();
 121   g_app_show_startup_type = startup_type;
 122
 123   Profile* current_profile = service->GetCurrentAppListProfile();
 124   if (!current_profile)
 125     g_profile_load_state = PROFILE_LOADED_NONE;
 126   else if (current_profile == launch_profile)
 127     g_profile_load_state = PROFILE_LOADED_SAME;
 128   else
 129     g_profile_load_state = PROFILE_LOADED_OTHER;
 130
 131   service->SetAppListNextPaintCallback(RecordFirstPaintTiming);
 132 }
 133
 134 }  // namespace
 135
 136 // static
 137 void AppListService::RegisterPrefs(PrefRegistrySimple* registry) {
 138   registry->RegisterInt64Pref(prefs::kLastAppListLaunchPing, 0);
 139   registry->RegisterIntegerPref(prefs::kAppListLaunchCount, 0);
 140   registry->RegisterInt64Pref(prefs::kLastAppListAppLaunchPing, 0);
 141   registry->RegisterIntegerPref(prefs::kAppListAppLaunchCount, 0);
 142   registry->RegisterStringPref(prefs::kAppListProfile, std::string());
 143   registry->RegisterBooleanPref(prefs::kAppLauncherIsEnabled, false);
 144   registry->RegisterBooleanPref(prefs::kAppLauncherHasBeenEnabled, false);
 145   registry->RegisterIntegerPref(prefs::kAppListEnableMethod,
 146                                 ENABLE_NOT_RECORDED);
 147   registry->RegisterInt64Pref(prefs::kAppListEnableTime, 0);
 148
 149 #if defined(OS_MACOSX)
 150   registry->RegisterIntegerPref(prefs::kAppLauncherShortcutVersion, 0);
 151 #endif
 152
 153   // Identifies whether we should show the app launcher promo or not.
 154   // Note that a field trial also controls the showing, so the promo won't show
 155   // unless the pref is set AND the field trial is set to a proper group.
 156   registry->RegisterBooleanPref(prefs::kShowAppLauncherPromo, true);
 157 }
 158
 159 // static
 160 bool AppListService::HandleLaunchCommandLine(
 161     const base::CommandLine& command_line,
 162     Profile* launch_profile) {
 163   InitAll(launch_profile);
 164   if (!command_line.HasSwitch(switches::kShowAppList))
 165     return false;
 166
 167   // The --show-app-list switch is used for shortcuts on the native desktop.
 168   AppListService* service = Get(chrome::HOST_DESKTOP_TYPE_NATIVE);
 169   DCHECK(service);
 170   RecordStartupInfo(service, command_line, launch_profile);
 171   service->ShowForProfile(launch_profile);
 172   return true;
 173 }