Implement an AutoLaunch experiment for Chrome for certain brand codes.

chrome/browser/ui/browser_init.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/browser_init.h"
 
 #include <algorithm>   // For max().
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/environment.h"
 #include "base/event_recorder.h"
 #include "base/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/browser/auto_launch_trial.h"
 #include "chrome/browser/automation/automation_provider.h"
 #include "chrome/browser/automation/automation_provider_list.h"
 #include "chrome/browser/automation/chrome_frame_automation_provider.h"
 #include "chrome/browser/automation/testing_automation_provider.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/component_updater/component_updater_service.h"
 #include "chrome/browser/component_updater/flash_component_installer.h"
 #include "chrome/browser/component_updater/recovery_component_installer.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 #include "chrome/browser/defaults.h"
@@ skipping 75 matching lines @@
 #include "chrome/browser/chromeos/sms_observer.h"
 #if defined(TOOLKIT_USES_GTK)
 #include "chrome/browser/chromeos/legacy_window_manager/wm_message_listener.h"
 #endif
 #endif
 
 #if defined(TOOLKIT_VIEWS) && defined(OS_LINUX)
 #include "ui/base/touch/touch_factory.h"
 #endif
 
+#if defined(OS_WIN)
+#include "chrome/installer/util/auto_launch_util.h"
+#endif
+
 using content::BrowserThread;
 
 namespace {
 
+static const int kMaxInfobarShown = 5;
+
+#if defined(OS_WIN)
+// The delegate for the infobar shown when Chrome was auto-launched.
+class AutolaunchInfoBarDelegate : public ConfirmInfoBarDelegate {
+ public:
+  AutolaunchInfoBarDelegate(InfoBarTabHelper* infobar_helper,
+                            PrefService* prefs);
+  virtual ~AutolaunchInfoBarDelegate();
+
+ private:
+  void AllowExpiry() { should_expire_ = true; }
+
+  // ConfirmInfoBarDelegate:
+  virtual bool ShouldExpire(
+      const content::LoadCommittedDetails& details) const OVERRIDE;
+  virtual gfx::Image* GetIcon() const OVERRIDE;
+  virtual string16 GetMessageText() const OVERRIDE;
+  virtual string16 GetButtonLabel(InfoBarButton button) const OVERRIDE;
+  virtual bool Accept() OVERRIDE;
+  virtual bool Cancel() OVERRIDE;
+
+  // The prefs to use.
+  PrefService* prefs_;
+
+  // Whether the user clicked one of the buttons.
+  bool action_taken_;
+
+  // Whether the info-bar should be dismissed on the next navigation.
+  bool should_expire_;
+
+  // Used to delay the expiration of the info-bar.
+  base::WeakPtrFactory<AutolaunchInfoBarDelegate> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(AutolaunchInfoBarDelegate);
+};
+
+AutolaunchInfoBarDelegate::AutolaunchInfoBarDelegate(
+    InfoBarTabHelper* infobar_helper,
+    PrefService* prefs)
+    : ConfirmInfoBarDelegate(infobar_helper),
+      prefs_(prefs),
+      action_taken_(false),
+      should_expire_(false),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
+  auto_launch_trial::UpdateInfobarShownMetric();
+
+  int count = prefs_->GetInteger(prefs::kShownAutoLaunchInfobar);
+  prefs_->SetInteger(prefs::kShownAutoLaunchInfobar, count + 1);
+
+  // We want the info-bar to stick-around for a few seconds and then be hidden
+  // on the next navigation after that.
+  MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&AutolaunchInfoBarDelegate::AllowExpiry,
+                 weak_factory_.GetWeakPtr()),
+      8000);  // 8 seconds.
+}
+
+AutolaunchInfoBarDelegate::~AutolaunchInfoBarDelegate() {
+  if (!action_taken_) {
+    auto_launch_trial::UpdateInfobarResponseMetric(
+        auto_launch_trial::INFOBAR_IGNORE);
+  }
+}
+
+bool AutolaunchInfoBarDelegate::ShouldExpire(
+    const content::LoadCommittedDetails& details) const {
+  return details.is_navigation_to_different_page() && should_expire_;
+}
+
+gfx::Image* AutolaunchInfoBarDelegate::GetIcon() const {
+  return &ResourceBundle::GetSharedInstance().GetNativeImageNamed(
+      IDR_PRODUCT_LOGO_32);
+}
+
+string16 AutolaunchInfoBarDelegate::GetMessageText() const {
+  return l10n_util::GetStringFUTF16(IDS_AUTO_LAUNCH_INFOBAR_TEXT,
+      l10n_util::GetStringUTF16(IDS_PRODUCT_NAME));
+}
+
+string16 AutolaunchInfoBarDelegate::GetButtonLabel(
+    InfoBarButton button) const {
+  return l10n_util::GetStringUTF16((button == BUTTON_OK) ?
+      IDS_AUTO_LAUNCH_OK : IDS_AUTO_LAUNCH_REVERT);
+}
+
+bool AutolaunchInfoBarDelegate::Accept() {
+  action_taken_ = true;
+  auto_launch_trial::UpdateInfobarResponseMetric(
+      auto_launch_trial::INFOBAR_OK);
+  return true;
+}
+
+bool AutolaunchInfoBarDelegate::Cancel() {
+  action_taken_ = true;
+
+  // Track infobar reponse.
+  auto_launch_trial::UpdateInfobarResponseMetric(
+      auto_launch_trial::INFOBAR_CUT_IT_OUT);
+  // Also make sure we keep track of how many disable and how many enable.
+  const bool auto_launch = false;
+  auto_launch_trial::UpdateToggleAutoLaunchMetric(auto_launch);
+
+  content::BrowserThread::PostTask(
+      content::BrowserThread::FILE, FROM_HERE,
+      base::Bind(&auto_launch_util::SetWillLaunchAtLogin,
+                 auto_launch, FilePath()));
+  return true;
+}
+
+#endif  // OS_WIN
+
 // DefaultBrowserInfoBarDelegate ----------------------------------------------
 
 // The delegate for the infobar shown when Chrome is not the default browser.
 class DefaultBrowserInfoBarDelegate : public ConfirmInfoBarDelegate {
  public:
   explicit DefaultBrowserInfoBarDelegate(InfoBarTabHelper* infobar_helper,
                                          PrefService* prefs);
 
  private:
   virtual ~DefaultBrowserInfoBarDelegate();
@@ skipping 83 matching lines @@
 }
 
 bool DefaultBrowserInfoBarDelegate::Cancel() {
   action_taken_ = true;
   UMA_HISTOGRAM_COUNTS("DefaultBrowserWarning.DontSetAsDefault", 1);
   // User clicked "Don't ask me again", remember that.
   prefs_->SetBoolean(prefs::kCheckDefaultBrowser, false);
   return true;
 }
 
+#if defined(OS_WIN)
+void CheckAutoLaunchCallback() {
+  if (!auto_launch_trial::IsInAutoLaunchGroup())
+    return;
+
+  Browser* browser = BrowserList::GetLastActive();
+  TabContentsWrapper* tab = browser->GetSelectedTabContentsWrapper();
+
+  int infobar_shown =
+      tab->profile()->GetPrefs()->GetInteger(prefs::kShownAutoLaunchInfobar);
+  if (infobar_shown >= kMaxInfobarShown)
+    return;
+
+  InfoBarTabHelper* infobar_helper = tab->infobar_tab_helper();
+  infobar_helper->AddInfoBar(
+      new AutolaunchInfoBarDelegate(infobar_helper,
+      tab->profile()->GetPrefs()));
+}
+#endif
+
 void NotifyNotDefaultBrowserCallback() {
   Browser* browser = BrowserList::GetLastActive();
   if (!browser)
     return;  // Reached during ui tests.
 
   // In ChromeBot tests, there might be a race. This line appears to get
   // called during shutdown and |tab| can be NULL.
   TabContentsWrapper* tab = browser->GetSelectedTabContentsWrapper();
   if (!tab)
     return;
@@ skipping 272 matching lines @@
 
 void BrowserInit::AddFirstRunTab(const GURL& url) {
   first_run_tabs_.push_back(url);
 }
 
 // static
 bool BrowserInit::InProcessStartup() {
   return in_startup;
 }
 
+// static
+void BrowserInit::RegisterUserPrefs(PrefService* prefs) {
+  prefs->RegisterIntegerPref(
+      prefs::kShownAutoLaunchInfobar, 0, PrefService::UNSYNCABLE_PREF);
+}
+
 bool BrowserInit::LaunchBrowser(const CommandLine& command_line,
                                 Profile* profile,
                                 const FilePath& cur_dir,
                                 IsProcessStartup process_startup,
                                 IsFirstRun is_first_run,
                                 int* return_code) {
   in_startup = process_startup == IS_PROCESS_STARTUP;
   DCHECK(profile);
 
   // Continue with the incognito profile from here on if Incognito mode
@@ skipping 156 matching lines @@
                               LM_TO_BE_DECIDED : LM_WITH_URLS);
     ProcessLaunchURLs(process_startup, urls_to_open);
 
     // If this is an app launch, but we didn't open an app window, it may
     // be an app tab.
     OpenApplicationTab(profile);
 
     if (process_startup) {
       if (browser_defaults::kOSSupportsOtherBrowsers &&
           !command_line_.HasSwitch(switches::kNoDefaultBrowserCheck)) {
+        CheckIfAutoLaunched(profile);
+
         // Check whether we are the default browser.
         CheckDefaultBrowser(profile);
       }
 #if defined(OS_MACOSX)
       // Check whether the auto-update system needs to be promoted from user
       // to system.
       KeystoneInfoBar::PromotionInfoBar(profile);
 #endif
     }
   }
@@ skipping 590 matching lines @@
     } else {
       // TODO(pastarmovj): We can't really do anything meaningful here yet but
       // just prevent showing the infobar.
     }
     return;
   }
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE, base::Bind(&CheckDefaultBrowserCallback));
 }
 
+void BrowserInit::LaunchWithProfile::CheckIfAutoLaunched(Profile* profile) {
+#if defined(OS_WIN)
+  if (!auto_launch_trial::IsInAutoLaunchGroup())
+    return;
+
+  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+  if (command_line.HasSwitch(switches::kAutoLaunchAtStartup)) {
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::Bind(&CheckAutoLaunchCallback));
+  }
+#endif
+}
+
 std::vector<GURL> BrowserInit::GetURLsFromCommandLine(
     const CommandLine& command_line,
     const FilePath& cur_dir,
     Profile* profile) {
   std::vector<GURL> urls;
   const CommandLine::StringVector& params = command_line.GetArgs();
 
   for (size_t i = 0; i < params.size(); ++i) {
     FilePath param = FilePath(params[i]);
     // Handle Vista way of searching - "? <search-term>"
@@ skipping 225 matching lines @@
 
   Profile* profile = ProfileManager::GetLastUsedProfile();
   if (!profile) {
     // We should only be able to get here if the profile already exists and
     // has been created.
     NOTREACHED();
     return;
   }
   ProcessCmdLineImpl(cmd_line, cur_dir, false, profile, NULL, NULL);
 }