Prevent GetDeviceId from invoking its callback multiple times in failure cases.

chrome/browser/prefs/pref_metrics_service.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/prefs/pref_metrics_service.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/metrics/histogram.h"
@@ skipping 245 matching lines @@
   base::HistogramBase* histogram = base::LinearHistogram::FactoryGet(
       histogram_name,
       1,
       boundary_value,
       boundary_value + 1,
       base::HistogramBase::kUmaTargetedHistogramFlag);
   histogram->Add(integer_value);
 }
 
 void PrefMetricsService::GetDeviceIdCallback(const std::string& device_id) {
+#if !defined(OS_WIN) || defined(ENABLE_RLZ)
+  // A device_id is expected in all scenarios except when RLZ is disabled on
+  // Windows.
+  DCHECK(!device_id.empty());
+#endif
+
   device_id_ = device_id;
-  // On Aura, this seems to be called twice.
-  if (!checked_tracked_prefs_)
-    CheckTrackedPreferences();
+  CheckTrackedPreferences();
 }
 
 void PrefMetricsService::MarkNeedsEmptyValueForTrackedPreferences() {
   for (int i = 0; i < tracked_pref_path_count_; ++i) {
     // Skip prefs that haven't been registered.
     if (!prefs_->FindPreference(tracked_pref_paths_[i]))
       continue;
 
     // Make sure tracked prefs are saved to disk even if empty.
     // TODO(gab): Guarantee this for all prefs at a lower level and remove this
     // hack.
     prefs_->MarkUserStoreNeedsEmptyValue(tracked_pref_paths_[i]);
   }
 }
 
 // To detect changes to Preferences that happen outside of Chrome, we hash
 // selected pref values and save them in local state. CheckTrackedPreferences
 // compares the saved values to the values observed in the profile's prefs. A
 // dictionary of dictionaries in local state holds the hashed values, grouped by
 // profile. To make the system more resistant to spoofing, pref values are
 // hashed with the pref path and the device id.
 void PrefMetricsService::CheckTrackedPreferences() {
+  // Make sure this is only called once per instance of this service.
   DCHECK(!checked_tracked_prefs_);
+  checked_tracked_prefs_ = true;
 
   const base::DictionaryValue* pref_hash_dicts =
       local_state_->GetDictionary(prefs::kProfilePreferenceHashes);
   // Get the hashed prefs dictionary if it exists. If it doesn't, it will be
   // created if we set preference values below.
   const base::DictionaryValue* hashed_prefs = NULL;
   pref_hash_dicts->GetDictionaryWithoutPathExpansion(profile_name_,
                                                      &hashed_prefs);
   for (int i = 0; i < tracked_pref_path_count_; ++i) {
     // Skip prefs that haven't been registered.
@@ skipping 38 matching lines @@
       }
     } else {
       // Record that we haven't tracked this preference yet, or the hash in
       // local state was removed.
       UMA_HISTOGRAM_ENUMERATION("Settings.TrackedPreferenceInitialized",
           i, tracked_pref_path_count_);
       UpdateTrackedPreference(tracked_pref_paths_[i]);
     }
   }
 
-  checked_tracked_prefs_ = true;
-
   // Now that we've checked the incoming preferences, register for change
   // notifications, unless this is test code.
   // TODO(bbudge) Fix failing browser_tests and so we can remove this test.
   // Several tests fail when they shutdown before they can write local state.
   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kTestType) &&
       !CommandLine::ForCurrentProcess()->HasSwitch(switches::kChromeFrame)) {
     InitializePrefObservers();
   }
 }
 
@@ skipping 103 matching lines @@
 }
 
 bool PrefMetricsService::Factory::ServiceIsNULLWhileTesting() const {
   return false;
 }
 
 content::BrowserContext* PrefMetricsService::Factory::GetBrowserContextToUse(
     content::BrowserContext* context) const {
   return chrome::GetBrowserContextRedirectedInIncognito(context);
 }