Primary histograms for InBrowserCleanerUI experiment

chrome/browser/safe_browsing/chrome_cleaner/reporter_runner_win.cc

 // Copyright 2015 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/safe_browsing/chrome_cleaner/reporter_runner_win.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 478 matching lines @@
                       ChromeCleanerFetchStatus fetch_status) {
   // As long as the fetch didn't fail due to HTTP_NOT_FOUND, show a prompt
   // (either offering the tool directly or pointing to the download page).
   // If the fetch failed to find the file, don't prompt the user since the
   // tool is not currently available.
   // TODO(csharp): In the event the browser is closed before the prompt
   //               displays, we will wait until the next scanner run to
   //               re-display it.  Improve this. http://crbug.com/460295
   if (fetch_status == ChromeCleanerFetchStatus::kNotFoundOnServer) {
     RecordSRTPromptHistogram(SRT_PROMPT_DOWNLOAD_UNAVAILABLE);
+    RecordPromptNotShownWithReasonHistogram(
+        NO_PROMPT_REASON_CLEANER_DOWNLOAD_FAILED);
     return;
   }
 
   // Find the last active browser, which may be NULL, in which case we won't
   // show the prompt this time and will wait until the next run of the
   // reporter. We can't use other ways of finding a browser because we don't
   // have a profile.
   Browser* browser = chrome::FindLastActive();
-  if (!browser)
+  if (!browser) {
+    RecordPromptNotShownWithReasonHistogram(
+        NO_PROMPT_REASON_BROWSER_NOT_AVAILABLE);
     return;
+  }
 
   Profile* profile = browser->profile();
   DCHECK(profile);
 
   // Make sure we have a tabbed browser since we need to anchor the bubble to
   // the toolbar's wrench menu. Create one if none exist already.
   if (browser->type() != Browser::TYPE_TABBED) {
     browser = chrome::FindTabbedBrowser(profile, false);
     if (!browser)
       browser = new Browser(Browser::CreateParams(profile, false));
@@ skipping 62 matching lines @@
 
 void ScanAndPrompt(const SwReporterInvocation& reporter_invocation) {
   if (g_testing_delegate_) {
     g_testing_delegate_->TriggerPrompt();
     return;
   }
 
   ChromeCleanerController* cleaner_controller =
       ChromeCleanerController::GetInstance();
 
-  if (cleaner_controller->state() != ChromeCleanerController::State::kIdle)
+  if (cleaner_controller->state() != ChromeCleanerController::State::kIdle) {
+    RecordPromptNotShownWithReasonHistogram(NO_PROMPT_REASON_NOT_ON_IDLE_STATE);
     return;
+  }
 
   cleaner_controller->Scan(reporter_invocation);
   DCHECK_EQ(ChromeCleanerController::State::kScanning,
             cleaner_controller->state());
 
   // The dialog controller manages its own lifetime. If the controller enters
   // the kInfected state, the dialog controller will show the chrome cleaner
   // dialog to the user.
   new ChromeCleanerDialogControllerImpl(cleaner_controller);
 }
@@ skipping 14 matching lines @@
   // Don't show the prompt again if it's been shown before for this profile
   // and for the current variations seed, unless there's a pending prompt to
   // show in the Chrome menu.
   std::string incoming_seed = GetIncomingSRTSeed();
   std::string old_seed = prefs->GetString(prefs::kSwReporterPromptSeed);
   PrefService* local_state = g_browser_process->local_state();
   bool pending_prompt =
       local_state && local_state->GetBoolean(prefs::kSwReporterPendingPrompt);
   if (!incoming_seed.empty() && incoming_seed == old_seed && !pending_prompt) {
     RecordReporterStepHistogram(SW_REPORTER_ALREADY_PROMPTED);
+    RecordPromptNotShownWithReasonHistogram(NO_PROMPT_REASON_ALREADY_PROMPTED);
     return;
   }
 
   if (!incoming_seed.empty() && incoming_seed != old_seed) {
     prefs->SetString(prefs::kSwReporterPromptSeed, incoming_seed);
     // Forget about pending prompts if prompt seed has changed.
     if (local_state)
       local_state->SetBoolean(prefs::kSwReporterPendingPrompt, false);
   }
   prefs->SetString(prefs::kSwReporterPromptVersion,
@@ skipping 127 matching lines @@
                             now.ToInternalValue());
     }
     uma.ReportRuntime(reporter_running_time);
     uma.ReportScanTimes();
     uma.ReportMemoryUsage();
     if (finished_invocation.logs_upload_enabled)
       uma.RecordLogsUploadResult();
 
     if (!finished_invocation.BehaviourIsSupported(
             SwReporterInvocation::BEHAVIOUR_TRIGGER_PROMPT)) {
+      RecordPromptNotShownWithReasonHistogram(
+          NO_PROMPT_REASON_BEHAVIOUR_NOT_SUPPORTED);
       return;
     }
 
     if (!base::FeatureList::IsEnabled(kInBrowserCleanerUIFeature) &&
         !IsInSRTPromptFieldTrialGroups()) {
       // Knowing about disabled field trial is more important than reporter not
       // finding anything to remove, so check this case first.
       RecordReporterStepHistogram(SW_REPORTER_NO_PROMPT_FIELD_TRIAL);
+      RecordPromptNotShownWithReasonHistogram(
+          NO_PROMPT_REASON_FEATURE_NOT_ENABLED);
       return;
     }
 
     if (exit_code != chrome_cleaner::kSwReporterPostRebootCleanupNeeded &&
         exit_code != chrome_cleaner::kSwReporterCleanupNeeded) {
       RecordReporterStepHistogram(SW_REPORTER_NO_PROMPT_NEEDED);
+      RecordPromptNotShownWithReasonHistogram(NO_PROMPT_REASON_NOTHING_FOUND);
       return;
     }
 
     // The kInBrowserCleanerUI feature takes precedence over the
     // SRTPromptFieldTrial. If it is enabled, no attempt will be made to show
     // the old SRT prompt.
     if (base::FeatureList::IsEnabled(kInBrowserCleanerUIFeature)) {
       ScanAndPrompt(finished_invocation);
       return;
     }
@@ skipping 223 matching lines @@
   return srt_cleaner_key.Open(HKEY_CURRENT_USER, cleaner_key_path.c_str(),
                               KEY_QUERY_VALUE) == ERROR_SUCCESS &&
          srt_cleaner_key.GetValueCount() > 0;
 }
 
 void SetSwReporterTestingDelegate(SwReporterTestingDelegate* delegate) {
   g_testing_delegate_ = delegate;
 }
 
 }  // namespace safe_browsing