Finch experiment for limiting the password bubble annoyance.

chrome/browser/ui/passwords/password_bubble_experiment.cc

+// Copyright 2014 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/passwords/password_bubble_experiment.h"
+
+#include "base/metrics/field_trial.h"
+#include "base/prefs/pref_service.h"
+#include "base/rand_util.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/time/time.h"
+#include "chrome/common/pref_names.h"
+#include "components/pref_registry/pref_registry_syncable.h"
+#include "components/variations/variations_associated_data.h"
+
+namespace password_bubble_experiment {
+namespace {
+
+bool IsNegativeEvent(password_manager::metrics_util::UIDismissalReason reason) {
+  return (reason == password_manager::metrics_util::NO_DIRECT_INTERACTION ||
+          reason == password_manager::metrics_util::CLICKED_NOPE ||
+          reason == password_manager::metrics_util::CLICKED_NEVER);
+}
+
+// "TimeSpan" experiment -----------------------------------------------------
+
+bool ExtractTimeSpanParams(base::TimeDelta* time_delta, int* nopes_limit) {
+  std::map<std::string, std::string> params;
+  bool retrieved = variations::GetVariationParams(kExperimentName, &params);
+  if (!retrieved)
+    return false;
+  int days = 0;
+  if (!base::StringToInt(params[kParamTimeSpan], &days) ||
+      !base::StringToInt(params[kParamTimeSpanNopeThreshold], nopes_limit))
+    return false;
+  *time_delta = base::TimeDelta::FromDays(days);
+  return true;
+}
+
+bool OverwriteTimeSpanPrefsIfNeeded(PrefService* prefs,
+                                    base::TimeDelta time_span) {
+  base::Time beginning = base::Time::FromInternalValue(
+      prefs->GetInt64(prefs::kPasswordBubbleTimeStamp));
+  base::Time now = base::Time::Now();
+  if (beginning + time_span < now) {
+    prefs->SetInt64(prefs::kPasswordBubbleTimeStamp, now.ToInternalValue());
+    prefs->SetInteger(prefs::kPasswordBubbleNopesCount, 0);
+    return true;
+  }
+  return false;
+}
+
+// If user dismisses the bubble >= kParamTimeSpanNopeThreshold times during
+// kParamTimeSpan days then the bubble isn't shown until the end of this time
+// span.
+bool ShouldShowBubbleTimeSpanExperiment(PrefService* prefs) {
+  base::TimeDelta time_span;
+  int nopes_limit = 0;
+  if (!ExtractTimeSpanParams(&time_span, &nopes_limit)) {
+    VLOG(2) << "Can't read parameters for "
+        << kExperimentName  << " experiment";
+    return true;
+  }
+  // Check if the new time span has started.
+  if (OverwriteTimeSpanPrefsIfNeeded(prefs, time_span))
+    return true;
+  int current_nopes = prefs->GetInteger(prefs::kPasswordBubbleNopesCount);
+  return current_nopes < nopes_limit;
+}
+
+// Increase the "Nope" counter in prefs and start a new time span if needed.
+void UpdateTimeSpanPrefs(
+    PrefService* prefs,
+    password_manager::metrics_util::UIDismissalReason reason) {
+  if (!IsNegativeEvent(reason))
+    return;
+  base::TimeDelta time_span;
+  int nopes_limit = 0;
+  if (!ExtractTimeSpanParams(&time_span, &nopes_limit)) {
+    VLOG(2) << "Can't read parameters for "
+        << kExperimentName << " experiment";
+    return;
+  }
+  OverwriteTimeSpanPrefsIfNeeded(prefs, time_span);
+  int current_nopes = prefs->GetInteger(prefs::kPasswordBubbleNopesCount);
+  prefs->SetInteger(prefs::kPasswordBubbleNopesCount, current_nopes + 1);
+}
+
+// "Probability" experiment --------------------------------------------------
+
+bool ExtractProbabilityParams(unsigned* history_length, unsigned* saves) {
+  std::map<std::string, std::string> params;
+  bool retrieved = variations::GetVariationParams(kExperimentName, &params);
+  if (!retrieved)
+    return false;
+  return base::StringToUint(params[kParamProbabilityInteractionsCount],
+                            history_length) &&
+      base::StringToUint(params[kParamProbabilityFakeSaves], saves);
+}
+
+std::vector<int> ReadInteractionHistory(PrefService* prefs) {
+  std::vector<int> interactions;
+  const base::ListValue* list =
+      prefs->GetList(prefs::kPasswordBubbleLastInteractions);
+  if (!list)
+    return interactions;
+  for (const base::Value* value : *list) {
+    int out_value;
+    if (value->GetAsInteger(&out_value))
+      interactions.push_back(out_value);
+  }
+  return interactions;
+}
+
+// We keep the history of last kParamProbabilityInteractionsCount interactions
+// with the bubble. We implicitly add kParamProbabilityFakeSaves "Save" clicks.
+// If there are x "Save" clicks among those kParamProbabilityInteractionsCount
+// then the bubble is shown with probability (x + kParamProbabilityFakeSaves)/
+// (kParamProbabilityInteractionsCount + kParamProbabilityFakeSaves).
+bool ShouldShowBubbleProbabilityExperiment(PrefService* prefs) {
+  unsigned history_length = 0, fake_saves = 0;
+  if (!ExtractProbabilityParams(&history_length, &fake_saves)) {
+    VLOG(2) << "Can't read parameters for "
+        << kExperimentName << " experiment";
+    return true;
+  }
+  std::vector<int> interactions = ReadInteractionHistory(prefs);
+  unsigned real_saves =
+      std::count(interactions.begin(), interactions.end(),
+                 password_manager::metrics_util::CLICKED_SAVE);
+  return (interactions.size() + fake_saves) * base::RandDouble() <=
+      real_saves + fake_saves;
+}
+
+void UpdateProbabilityPrefs(
+    PrefService* prefs,
+    password_manager::metrics_util::UIDismissalReason reason) {
+  if (!IsNegativeEvent(reason) &&
+      reason != password_manager::metrics_util::CLICKED_SAVE)
+    return;
+  unsigned history_length = 0, fake_saves = 0;
+  if (!ExtractProbabilityParams(&history_length, &fake_saves)) {
+    VLOG(2) << "Can't read parameters for "
+        << kExperimentName << " experiment";
+    return;
+  }
+  std::vector<int> interactions = ReadInteractionHistory(prefs);
+  interactions.push_back(reason);
+  size_t history_beginning = interactions.size() > history_length ?
+      interactions.size() - history_length : 0;
+  base::ListValue value;
+  for (size_t i = history_beginning; i < interactions.size(); ++i)
+    value.AppendInteger(interactions[i]);
+  prefs->Set(prefs::kPasswordBubbleLastInteractions, value);
+}
+
+} // namespace
+
+const char kExperimentName[] = "PasswordBubbleAlgorithm";
+const char kGroupTimeSpanBased[] = "TimeSpan";
+const char kGroupProbabilityBased[] = "Probability";
+const char kParamProbabilityFakeSaves[] = "saves_count";
+const char kParamProbabilityInteractionsCount[] = "last_interactions_count";
+const char kParamTimeSpan[] = "time_span";
+const char kParamTimeSpanNopeThreshold[] = "nope_threshold";
+
+void RegisterPrefs(user_prefs::PrefRegistrySyncable* registry) {
+  registry->RegisterInt64Pref(
+      prefs::kPasswordBubbleTimeStamp,
+      0,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterIntegerPref(
+      prefs::kPasswordBubbleNopesCount,
+      0,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+  registry->RegisterListPref(
+      prefs::kPasswordBubbleLastInteractions,
+      user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
+}
+
+bool ShouldShowBubble(PrefService* prefs) {
+  if (!base::FieldTrialList::TrialExists(kExperimentName))
+    return true;
+  std::string group_name =
+      base::FieldTrialList::FindFullName(kExperimentName);
+
+  if (group_name == kGroupTimeSpanBased) {
+    return ShouldShowBubbleTimeSpanExperiment(prefs);
+  }
+  if (group_name == kGroupProbabilityBased) {
+    return ShouldShowBubbleProbabilityExperiment(prefs);
+  }
+
+  // The "Show Always" should be the default case.
+  return true;
+}
+
+void RecordBubbleClosed(
+    PrefService* prefs,
+    password_manager::metrics_util::UIDismissalReason reason) {
+  UpdateTimeSpanPrefs(prefs, reason);
+  UpdateProbabilityPrefs(prefs, reason);
+}
+
+}  // namespace password_bubble_experiment