Implement the UI logic behind the Sign In promo in the password bubble

chrome/browser/ui/passwords/manage_passwords_bubble_model.cc

 // Copyright 2013 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/manage_passwords_bubble_model.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
 
+#include "base/metrics/histogram_macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/default_clock.h"
 #include "chrome/browser/password_manager/password_store_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/profile_sync_service_factory.h"
 #include "chrome/browser/ui/passwords/manage_passwords_view_utils.h"
 #include "chrome/browser/ui/passwords/passwords_model_delegate.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/browser_sync/browser/profile_sync_service.h"
@@ skipping 65 matching lines @@
   void set_dismissal_reason(
       password_manager::metrics_util::UIDismissalReason reason) {
     dismissal_reason_ = reason;
   }
 
   void set_update_password_submission_event(
       password_manager::metrics_util::UpdatePasswordSubmissionEvent event) {
     update_password_submission_event_ = event;
   }
 
+  void set_sign_in_promo_dismissal_reason(
+      password_manager::metrics_util::SyncSignInUserAction reason) {
+    sign_in_promo_dismissal_reason_ = reason;
+  }
+
   void SetClockForTesting(std::unique_ptr<base::Clock> clock) {
     clock_ = std::move(clock);
   }
 
  private:
   // The way the bubble appeared.
   const password_manager::metrics_util::UIDisplayDisposition
   display_disposition_;
 
   // Dismissal reason for a bubble.
   password_manager::metrics_util::UIDismissalReason dismissal_reason_;
 
   // Dismissal reason for the update bubble.
   password_manager::metrics_util::UpdatePasswordSubmissionEvent
       update_password_submission_event_;
 
+  // Dismissal reason for the Chrome Sign in bubble.
+  password_manager::metrics_util::SyncSignInUserAction
+      sign_in_promo_dismissal_reason_;
+
   // Current statistics for the save password bubble;
   password_manager::InteractionsStats interaction_stats_;
 
   // Used to retrieve the current time, in base::Time units.
   std::unique_ptr<base::Clock> clock_;
 
   DISALLOW_COPY_AND_ASSIGN(InteractionKeeper);
 };
 
 ManagePasswordsBubbleModel::InteractionKeeper::InteractionKeeper(
     password_manager::InteractionsStats stats,
     password_manager::metrics_util::UIDisplayDisposition display_disposition)
     : display_disposition_(display_disposition),
       dismissal_reason_(metrics_util::NO_DIRECT_INTERACTION),
       update_password_submission_event_(metrics_util::NO_UPDATE_SUBMISSION),
+      sign_in_promo_dismissal_reason_(metrics_util::CHROME_SIGNIN_DISMISSED),
       interaction_stats_(std::move(stats)),
-      clock_(new base::DefaultClock) {
-}
+      clock_(new base::DefaultClock) {}
 
 void ManagePasswordsBubbleModel::InteractionKeeper::ReportInteractions(
     const ManagePasswordsBubbleModel* model) {
   if (model->state() == password_manager::ui::PENDING_PASSWORD_STATE) {
     Profile* profile = model->GetProfile();
     if (profile) {
       if (GetSmartLockBrandingState(profile) ==
           password_bubble_experiment::SmartLockBranding::FULL) {
         password_bubble_experiment::RecordSavePromptFirstRunExperienceWasShown(
             profile->GetPrefs());
       }
       if (dismissal_reason_ == metrics_util::NO_DIRECT_INTERACTION &&
           display_disposition_ ==
               metrics_util::AUTOMATIC_WITH_PASSWORD_PENDING) {
         if (interaction_stats_.dismissal_count <
             std::numeric_limits<decltype(
                 interaction_stats_.dismissal_count)>::max())
           interaction_stats_.dismissal_count++;
         interaction_stats_.update_time = clock_->Now();
         password_manager::PasswordStore* password_store =
             PasswordStoreFactory::GetForProfile(
                 profile, ServiceAccessType::IMPLICIT_ACCESS).get();
         password_store->AddSiteStats(interaction_stats_);
       }
     }
   }
 
-  if (model->state() != password_manager::ui::PENDING_PASSWORD_UPDATE_STATE) {
+  if (model->state() == password_manager::ui::CHROME_SIGN_IN_PROMO_STATE) {
+    metrics_util::LogAutoSigninPromoUserAction(sign_in_promo_dismissal_reason_);
+    if (sign_in_promo_dismissal_reason_ ==
+            password_manager::metrics_util::CHROME_SIGNIN_OK ||
+        sign_in_promo_dismissal_reason_ ==
+            password_manager::metrics_util::CHROME_SIGNIN_CANCEL) {
+      // web_contents() can't be nullptr in this block.

[vabr (Chromium), 2016/06/06 15:23:14]

nit: The standard way to say this is:
DCHECK(web_contents());

[vasilii, 2016/06/06 15:45:14]

Done.

+      int show_count = model->GetProfile()->GetPrefs()->GetInteger(
+          password_manager::prefs::kNumberSignInPasswordPromoShown);
+      UMA_HISTOGRAM_COUNTS_100("PasswordManager.SignInPromoCountTilClick",
+                               show_count);
+    }
+  } else if (model->state() !=
+             password_manager::ui::PENDING_PASSWORD_UPDATE_STATE) {
     // We have separate metrics for the Update bubble so do not record dismissal
     // reason for it.
     metrics_util::LogUIDismissalReason(dismissal_reason_);
   }
 
-  PasswordsModelDelegate* delegate = model->web_contents()
-      ? PasswordsModelDelegateFromWebContents(model->web_contents())
-      : nullptr;
-  // Check if this was update password and record update statistics.
-  if (update_password_submission_event_ == metrics_util::NO_UPDATE_SUBMISSION &&
-      (model->state() == password_manager::ui::PENDING_PASSWORD_UPDATE_STATE ||
-          model->state() == password_manager::ui::PENDING_PASSWORD_STATE)) {
-    update_password_submission_event_ =
-        model->GetUpdateDismissalReason(NO_INTERACTION);
-    if (model->state() == password_manager::ui::PENDING_PASSWORD_UPDATE_STATE &&
-        delegate)
-      delegate->OnNoInteractionOnUpdate();
+  if (model->state() == password_manager::ui::PENDING_PASSWORD_UPDATE_STATE ||
+      model->state() == password_manager::ui::PENDING_PASSWORD_STATE) {
+    if (update_password_submission_event_ ==
+        metrics_util::NO_UPDATE_SUBMISSION) {
+      update_password_submission_event_ =
+          model->GetUpdateDismissalReason(NO_INTERACTION);
+      PasswordsModelDelegate* delegate =
+          model->web_contents()
+              ? PasswordsModelDelegateFromWebContents(model->web_contents())
+              : nullptr;
+      if (delegate &&
+          model->state() == password_manager::ui::PENDING_PASSWORD_UPDATE_STATE)
+        delegate->OnNoInteractionOnUpdate();
+    }
+
+    if (update_password_submission_event_ != metrics_util::NO_UPDATE_SUBMISSION)
+      LogUpdatePasswordSubmissionEvent(update_password_submission_event_);
   }
-  if (update_password_submission_event_ != metrics_util::NO_UPDATE_SUBMISSION)
-    LogUpdatePasswordSubmissionEvent(update_password_submission_event_);
 }
 
 ManagePasswordsBubbleModel::ManagePasswordsBubbleModel(
     content::WebContents* web_contents,
     DisplayReason display_reason)
     : content::WebContentsObserver(web_contents),
       password_overridden_(false) {
   PasswordsModelDelegate* delegate =
       PasswordsModelDelegateFromWebContents(web_contents);
 
@@ skipping 198 matching lines @@
       PasswordStoreFactory::GetForProfile(
           profile, ServiceAccessType::EXPLICIT_ACCESS).get();
   DCHECK(password_store);
   if (action == REMOVE_PASSWORD)
     password_store->RemoveLogin(password_form);
   else
     password_store->AddLogin(password_form);
 }
 
 void ManagePasswordsBubbleModel::OnSignInToChromeClicked() {
-
+  interaction_keeper_->set_sign_in_promo_dismissal_reason(
+      metrics_util::CHROME_SIGNIN_OK);
+  GetProfile()->GetPrefs()->SetBoolean(
+      password_manager::prefs::kWasSignInPasswordPromoClicked, true);
+  PasswordsModelDelegateFromWebContents(web_contents())
+      ->NavigateToChromeSignIn();
 }
 
 void ManagePasswordsBubbleModel::OnSkipSignInClicked() {
-
+  interaction_keeper_->set_sign_in_promo_dismissal_reason(
+      metrics_util::CHROME_SIGNIN_CANCEL);
+  GetProfile()->GetPrefs()->SetBoolean(
+      password_manager::prefs::kWasSignInPasswordPromoClicked, true);
 }
 
 Profile* ManagePasswordsBubbleModel::GetProfile() const {
   return GetProfileFromWebContents(web_contents());
 }
 
 bool ManagePasswordsBubbleModel::ShouldShowMultipleAccountUpdateUI() const {
   return state_ == password_manager::ui::PENDING_PASSWORD_UPDATE_STATE &&
          local_credentials_.size() > 1 && !password_overridden_;
 }
 
 bool ManagePasswordsBubbleModel::ShouldShowGoogleSmartLockWelcome() const {
   Profile* profile = GetProfile();
   if (GetSmartLockBrandingState(profile) ==
       password_bubble_experiment::SmartLockBranding::FULL) {
     PrefService* prefs = profile->GetPrefs();
     return !prefs->GetBoolean(
         password_manager::prefs::kWasSavePrompFirstRunExperienceShown);
   }
   return false;
 }
 
 bool ManagePasswordsBubbleModel::ReplaceToShowSignInPromoIfNeeded() {
   DCHECK_EQ(password_manager::ui::PENDING_PASSWORD_STATE, state_);
-  if (false /*TODO(crbug.com/615825): there will be a real condition soon*/) {
+  PrefService* prefs = GetProfile()->GetPrefs();
+  if (password_bubble_experiment::ShouldShowChromeSignInPasswordPromo(prefs)) {
+    interaction_keeper_->ReportInteractions(this);
     title_brand_link_range_ = gfx::Range();
     title_ = l10n_util::GetStringUTF16(IDS_PASSWORD_MANAGER_SIGNIN_PROMO_TITLE);
     state_ = password_manager::ui::CHROME_SIGN_IN_PROMO_STATE;
+    int show_count = prefs->GetInteger(
+        password_manager::prefs::kNumberSignInPasswordPromoShown);
+    prefs->SetInteger(password_manager::prefs::kNumberSignInPasswordPromoShown,
+                      show_count + 1);
     return true;
   }
   return false;
 }
 
 void ManagePasswordsBubbleModel::SetClockForTesting(
     std::unique_ptr<base::Clock> clock) {
   interaction_keeper_->SetClockForTesting(std::move(clock));
 }
 
@@ skipping 40 matching lines @@
     return metrics_util::NO_UPDATE_SUBMISSION;
   }
   if (state_ != password_manager::ui::PENDING_PASSWORD_UPDATE_STATE)
     return metrics_util::NO_UPDATE_SUBMISSION;
   if (password_overridden_)
     return update_events[3][behavior];
   if (ShouldShowMultipleAccountUpdateUI())
     return update_events[2][behavior];
   return update_events[1][behavior];
 }