Expand PrefHashBrowserTest to ensure unloaded profile initialization produces proper hashes.

chrome/browser/prefs/pref_hash_browsertest.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 <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
+#include "base/macros.h"
 #include "base/message_loop/message_loop.h"
+#include "base/metrics/histogram_base.h"
+#include "base/metrics/histogram_samples.h"
+#include "base/metrics/statistics_recorder.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string16.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/prefs/pref_hash_store.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_impl.h"
 #include "chrome/browser/profiles/profile_info_cache.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/profiles/profiles_state.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "content/public/test/test_utils.h"
 
 namespace {
@@ skipping 26 matching lines @@
   std::set<base::FilePath> profile_paths;
   for (size_t i = 0; i < cache.GetNumberOfProfiles(); ++i)
     profile_paths.insert(cache.GetPathOfProfileAtIndex(i));
   for (size_t i = 0; i < loaded_profiles.size(); ++i)
     EXPECT_EQ(1U, profile_paths.erase(loaded_profiles[i]->GetPath()));
   if (profile_paths.size())
     return *profile_paths.begin();
   return base::FilePath();
 }
 
+// Returns the number of times |histogram_name| was reported so far; adding the
+// results of the first 100 buckets (there are only ~14 reporting IDs as of this
+// writting; varies depending on the platform). If |expect_zero| is true, this
+// method will explicitly report IDs that are non-zero for ease of diagnosis.
+int GetTrackedPrefHistogramCount(const char* histogram_name, bool expect_zero) {
+  const base::HistogramBase* histogram =
+      base::StatisticsRecorder::FindHistogram(histogram_name);
+  if (!histogram)
+    return 0;
+
+  scoped_ptr<base::HistogramSamples> samples(histogram->SnapshotSamples());
+  int sum = 0;
+  for (int i = 0; i < 100; ++i) {
+    int count_for_id = samples->GetCount(i);
+    sum += count_for_id;
+
+    if (expect_zero)
+      EXPECT_EQ(0, count_for_id) << "Faulty reporting_id: " << i;
+  }
+  return sum;
+}
+
 }  // namespace
 
 typedef InProcessBrowserTest PrefHashBrowserTest;
 
 IN_PROC_BROWSER_TEST_F(PrefHashBrowserTest,
                        PRE_PRE_InitializeUnloadedProfiles) {
   if (!profiles::IsMultipleProfilesEnabled())
     return;
   ProfileManager* profile_manager = g_browser_process->profile_manager();
 
@@ skipping 39 matching lines @@
   ProfileImpl::ResetPrefHashStore(unloaded_profile_path);
 
   // One of the profile hash collections should be gone.
   ASSERT_EQ(2U, hashes->size());
 }
 
 IN_PROC_BROWSER_TEST_F(PrefHashBrowserTest,
                        InitializeUnloadedProfiles) {
   if (!profiles::IsMultipleProfilesEnabled())
     return;
 

[erikwright (departed), 2014/01/30 15:38:25]

I'm confused. I would have thought there would be a bunch of initialized MACs at
this point, since starting the browser up presumably had that effect.

[gab, 2014/01/30 15:58:52]

They were initialized in the PRE_* tests; now they should be Unchanged.

[erikwright (departed), 2014/01/30 16:05:58]

At the very end of the previous test we Reset them. And verified that there were
only two entries in the Local State hashes dictionary.

AFAICT, one of two things has happened:
(1) Initialization of the reset profile actually occurred some time during
shutdown of the PRE_ test.
(2) Initialization of the reset profile happened (as expected) during launch of
the final test but before we started collecting histograms?

[gab, 2014/01/30 16:19:18]

Oh you're referring to the initialization of the unloaded profile; Initialize()
does initialization directly without reporting (as desired) -- so no
Settings.TrackedPreference* histogram is expected from initializing the unloaded
profile -- only Settings.TrackedPreferencesInitializedForUnloadedProfile::true
is reported for the entire initialization (in fact I could check that this was
indeed reported here to make sure that this phase indeed did the initialization
(and not the shutdown of the previous phase).

[erikwright (departed), 2014/01/30 16:27:47]

Ah, right.

Yeah, that would be a good idea, I think.

LGTM, Would LEBTM if you added a check for that.

   const base::DictionaryValue* hashes =
       g_browser_process->local_state()->GetDictionary(
           prefs::kProfilePreferenceHashes);
 
   // The deleted hash collection should be restored.
   ASSERT_EQ(3U, hashes->size());
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
-  const std::vector<Profile*> loaded_profiles =
-      profile_manager->GetLoadedProfiles();
 
   // Verify that only one profile was loaded. We assume that the unloaded
   // profile is the same one that wasn't loaded in the last launch (i.e., it's
   // the one whose hash store we reset, and the fact that it is now restored is
   // evidence that we restored the hashes of an unloaded profile.).
-  ASSERT_EQ(1U, loaded_profiles.size());
+  ASSERT_EQ(1U, profile_manager->GetLoadedProfiles().size());
+
+  // Loading the first profile should only have produced unchanged reports.
+  EXPECT_EQ(
+      0, GetTrackedPrefHistogramCount(
+             "Settings.TrackedPreferenceChanged", true));
+  EXPECT_EQ(
+      0, GetTrackedPrefHistogramCount(
+             "Settings.TrackedPreferenceCleared", true));
+  EXPECT_EQ(
+      0, GetTrackedPrefHistogramCount(
+             "Settings.TrackedPreferenceInitialized", true));
+  EXPECT_EQ(
+      0, GetTrackedPrefHistogramCount(
+             "Settings.TrackedPreferenceTrustedInitialized", true));
+  EXPECT_EQ(
+      0, GetTrackedPrefHistogramCount(
+             "Settings.TrackedPreferenceMigrated", true));
+  int initial_unchanged_count =
+      GetTrackedPrefHistogramCount("Settings.TrackedPreferenceUnchanged",
+                                   false);
+  EXPECT_GT(initial_unchanged_count, 0);
+
+  // Explicitly load the unloaded profile.
+  profile_manager->GetProfile(GetUnloadedProfilePath());
+  ASSERT_EQ(2U, profile_manager->GetLoadedProfiles().size());
+
+  // Loading the unexpected profile should only generate unchanged pings; and
+  // should have produced as many of them as loading the first profile.
+  EXPECT_EQ(
+      0, GetTrackedPrefHistogramCount(
+             "Settings.TrackedPreferenceChanged", true));
+  EXPECT_EQ(
+      0, GetTrackedPrefHistogramCount(
+             "Settings.TrackedPreferenceCleared", true));
+  EXPECT_EQ(
+      0, GetTrackedPrefHistogramCount(
+             "Settings.TrackedPreferenceInitialized", true));
+  EXPECT_EQ(
+      0, GetTrackedPrefHistogramCount(
+             "Settings.TrackedPreferenceTrustedInitialized", true));
+  EXPECT_EQ(
+      0, GetTrackedPrefHistogramCount(
+             "Settings.TrackedPreferenceMigrated", true));
+  EXPECT_EQ(
+      initial_unchanged_count * 2,
+      GetTrackedPrefHistogramCount("Settings.TrackedPreferenceUnchanged",
+                                   false));
 }