Report user actions for interactions with the Windows Settings app.

chrome/browser/shell_integration_win.cc

 // Copyright (c) 2012 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/shell_integration_win.h"
 
 #include <windows.h>
 #include <shlwapi.h>
 #include <shobjidl.h>
 #include <propkey.h>  // Needs to come after shobjidl.h.
 #include <stddef.h>
 #include <stdint.h>
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/metrics/user_metrics.h"
+#include "base/metrics/user_metrics_action.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_propvariant.h"
 #include "base/win/shortcut.h"
 #include "base/win/windows_version.h"
 #include "chrome/browser/policy/policy_path_parser.h"
+#include "chrome/browser/settings_app_monitor_win.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths_internal.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/installer/setup/setup_util.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/create_reg_key_work_item.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/scoped_user_protocol_entry.h"
@@ skipping 159 matching lines @@
     case ShellUtil::NOT_DEFAULT:
       return DefaultWebClientState::NOT_DEFAULT;
     case ShellUtil::IS_DEFAULT:
       return DefaultWebClientState::IS_DEFAULT;
     default:
       DCHECK_EQ(ShellUtil::UNKNOWN_DEFAULT, default_state);
       return DefaultWebClientState::UNKNOWN_DEFAULT;
   }
 }
 
+// A recorder of user actions in the Windows Settings app.
+class DefaultBrowserActionRecorder : public win::SettingsAppMonitor::Delegate {
+ public:
+  // Creates the recorder and the monitor that drives it. |continuation| will be
+  // run once the monitor's initialization completes (regardless of success or
+  // failure).
+  explicit DefaultBrowserActionRecorder(base::Closure continuation)
+      : continuation_(std::move(continuation)), settings_app_monitor_(this) {}
+
+ private:
+  // win::SettingsAppMonitor::Delegate:
+  void OnInitialized(HRESULT result) override {
+    if (SUCCEEDED(result)) {
+      base::RecordAction(
+          base::UserMetricsAction("SettingsAppMonitor.Initialized"));
+    } else {
+      base::RecordAction(base::UserMetricsAction("SettingsAppMonitor.Failed"));
+    }
+    continuation_.Run();
+    continuation_ = base::Closure();
+  }
+
+  void OnAppFocused() override {
+    base::RecordAction(
+        base::UserMetricsAction("SettingsAppMonitor.AppFocused"));
+  }
+
+  void OnChooserInvoked() override {
+    base::RecordAction(
+        base::UserMetricsAction("SettingsAppMonitor.ChooserInvoked"));
+  }
+
+  void OnBrowserChosen(const base::string16& browser_name) override {
+    if (browser_name ==
+        BrowserDistribution::GetDistribution()->GetDisplayName()) {
+      base::RecordAction(
+          base::UserMetricsAction("SettingsAppMonitor.ChromeBrowserChosen"));
+    } else {
+      base::RecordAction(
+          base::UserMetricsAction("SettingsAppMonitor.OtherBrowserChosen"));
+    }
+  }
+
+  // A closure to be run once initialization completes.
+  base::Closure continuation_;
+
+  // Monitors user interaction with the Windows Settings app for the sake of
+  // reporting user actions.
+  win::SettingsAppMonitor settings_app_monitor_;
+
+  DISALLOW_COPY_AND_ASSIGN(DefaultBrowserActionRecorder);
+};
+
+// A function bound up in a callback with a DefaultBrowserActionRecorder and
+// a closure to keep the former alive until the time comes to run the latter.
+void OnSettingsAppFinished(
+    std::unique_ptr<DefaultBrowserActionRecorder> recorder,
+    const base::Closure& on_finished_callback) {
+  recorder.reset();
+  on_finished_callback.Run();
+}
+
 // There is no way to make sure the user is done with the system settings, but a
 // signal that the interaction is finished is needed for UMA. A timer of 2
 // minutes is used as a substitute. The registry keys for the protocol
 // association with an app are also monitored to signal the end of the
 // interaction early when it is clear that the user made a choice (e.g. http
 // and https for default browser).
 //
 // This helper class manages both the timer and the registry watchers and makes
 // sure the callback for the end of the settings interaction is only run once.
 // This class also manages its own lifetime.
@@ skipping 245 matching lines @@
     const base::Closure& on_finished_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   base::FilePath chrome_exe;
   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
     NOTREACHED() << "Error getting app exe path";
     on_finished_callback.Run();
     return;
   }
 
-  // The helper manages its own lifetime.
+  // Create an action recorder that will open the settings app once it has
+  // initialized.
+  std::unique_ptr<DefaultBrowserActionRecorder> recorder(
+      new DefaultBrowserActionRecorder(base::Bind(
+          base::IgnoreResult(&ShellUtil::ShowMakeChromeDefaultSystemUI),
+          base::Unretained(BrowserDistribution::GetDistribution()),
+          chrome_exe)));
+
+  // The helper manages its own lifetime. Bind the action recorder
+  // into the finished callback to keep it alive throughout the
+  // interaction.
   static const wchar_t* const kProtocols[] = {L"http", L"https", nullptr};
-  OpenSystemSettingsHelper::Begin(kProtocols, on_finished_callback);
-
-  BrowserDistribution* dist = BrowserDistribution::GetDistribution();
-  ShellUtil::ShowMakeChromeDefaultSystemUI(dist, chrome_exe);
+  OpenSystemSettingsHelper::Begin(
+      kProtocols, base::Bind(&OnSettingsAppFinished, base::Passed(&recorder),
+                             on_finished_callback));
 }
 
 bool SetAsDefaultProtocolClientUsingIntentPicker(const std::string& protocol) {
   base::FilePath chrome_exe;
   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
     NOTREACHED() << "Error getting app exe path";
     return false;
   }
 
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
@@ skipping 200 matching lines @@
     if (base::PathExists(shortcut))
       return shortcut;
   }
 
   return base::FilePath();
 }
 
 }  // namespace win
 
 }  // namespace shell_integration