Add callback list to PrefModelAssociator after sync data is loaded

components/content_settings/core/browser/host_content_settings_map.cc

 // Copyright (c) 2012 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 "components/content_settings/core/browser/host_content_settings_map.h"
 
 #include <stddef.h>
 
 #include <utility>
 
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/clock.h"
 #include "build/build_config.h"
 #include "components/content_settings/core/browser/content_settings_default_provider.h"
@@ skipping 111 matching lines @@
       patterns.first = ContentSettingsPattern::FromURLNoWildcard(primary_url);
       patterns.second =
           ContentSettingsPattern::FromURLNoWildcard(secondary_url);
       break;
   }
   return patterns;
 }
 
 }  // namespace
 
-HostContentSettingsMap::HostContentSettingsMap(PrefService* prefs,
-                                               bool is_incognito_profile,
-                                               bool is_guest_profile)
+HostContentSettingsMap::HostContentSettingsMap(
+    PrefService* prefs,
+    bool is_incognito_profile,
+    bool is_guest_profile,
+    syncable_prefs::PrefServiceSyncable* pref_service)
     :
 #ifndef NDEBUG
       used_from_thread_id_(base::PlatformThread::CurrentId()),
 #endif
       prefs_(prefs),
-      is_off_the_record_(is_incognito_profile || is_guest_profile) {
+      is_off_the_record_(is_incognito_profile || is_guest_profile),
+      pref_service_(pref_service) {
   DCHECK(!(is_incognito_profile && is_guest_profile));
 
   content_settings::PolicyProvider* policy_provider =
       new content_settings::PolicyProvider(prefs_);
   content_settings_providers_[POLICY_PROVIDER] = policy_provider;
   policy_provider->AddObserver(this);
 
   pref_provider_ =
       new content_settings::PrefProvider(prefs_, is_off_the_record_);
   content_settings_providers_[PREF_PROVIDER] = pref_provider_;
   pref_provider_->AddObserver(this);
 
   // This ensures that content settings are cleared for the guest profile. This
   // wouldn't be needed except that we used to allow settings to be stored for
   // the guest profile and so we need to ensure those get cleared.
   if (is_guest_profile)
     pref_provider_->ClearPrefs();
 
   content_settings::ObservableProvider* default_provider =
       new content_settings::DefaultProvider(prefs_, is_off_the_record_);
   default_provider->AddObserver(this);
   content_settings_providers_[DEFAULT_PROVIDER] = default_provider;
 
   MigrateKeygenSettings();
 
   RecordNumberOfExceptions();
+
+  if (pref_service_) {
+    pref_service_->RegisterMergeDataFinishedCallback(
+        base::Bind(&HostContentSettingsMap::MigrateDomainScopedSettings,
+                   base::Unretained(this)));

[raymes, 2016/06/29 03:50:01]

We should probably use a WeakPtr here instead of base::Unretained(this). That
will ensure that the callback doesn't get called if this object is destroyed.

I think we could also just pass "this", which would keep this object alive until
after the callback has run, but in this case we don't need to keep it alive and
it's probably better not to.

[lshang, 2016/06/30 05:03:36]

Done.

+  }
 }
 
 // static
 void HostContentSettingsMap::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   // Ensure the content settings are all registered.
   content_settings::ContentSettingsRegistry::GetInstance();
 
   registry->RegisterIntegerPref(prefs::kContentSettingsWindowLastTabIndex, 0);
 
@@ skipping 725 matching lines @@
         rule.secondary_pattern.Matches(secondary_url)) {
       if (primary_pattern)
         *primary_pattern = rule.primary_pattern;
       if (secondary_pattern)
         *secondary_pattern = rule.secondary_pattern;
       return base::WrapUnique(rule.value.get()->DeepCopy());
     }
   }
   return std::unique_ptr<base::Value>();
 }