Pref service: add support for tracked prefs.

chrome/browser/prefs/chrome_pref_service_factory.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 <chrome/browser/prefs/chrome_command_line_pref_store.h>
 #include "chrome/browser/prefs/chrome_pref_service_factory.h"
 
 #include <stddef.h>
 
 #include <string>
@@ skipping 40 matching lines @@
 #include "components/search_engines/search_engines_pref_names.h"
 #include "components/signin/core/common/signin_pref_names.h"
 #include "components/sync/base/model_type.h"
 #include "components/sync/base/pref_names.h"
 #include "components/sync_preferences/pref_model_associator.h"
 #include "components/sync_preferences/pref_service_syncable.h"
 #include "components/sync_preferences/pref_service_syncable_factory.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/features/features.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
 #include "rlz/features/features.h"
 #include "services/preferences/public/cpp/tracked/configuration.h"
 #include "services/preferences/public/cpp/tracked/pref_names.h"
 #include "sql/error_delegate_util.h"
 #include "ui/base/resource/resource_bundle.h"
 
 #if BUILDFLAG(ENABLE_EXTENSIONS)
 #include "extensions/browser/pref_names.h"
 #endif
 
@@ skipping 280 matching lines @@
   UMA_HISTOGRAM_BOOLEAN("Settings.LegacyMachineIdGenerationSuccess",
                         !legacy_device_id.empty());
 #endif
   std::string seed;
 #if defined(GOOGLE_CHROME_BUILD)
   seed = ResourceBundle::GetSharedInstance().GetRawDataResource(
       IDR_PREF_HASH_SEED_BIN).as_string();
 #endif
   return base::MakeUnique<ProfilePrefStoreManager>(
       profile_path, GetTrackingConfiguration(), kTrackedPrefsReportingIDsCount,
-      seed, legacy_device_id, g_browser_process->local_state());
+      seed, legacy_device_id);
 }
 
 void PrepareFactory(sync_preferences::PrefServiceSyncableFactory* factory,
                     const base::FilePath& pref_filename,
                     policy::PolicyService* policy_service,
                     SupervisedUserSettingsService* supervised_user_settings,
                     scoped_refptr<PersistentPrefStore> user_pref_store,
                     const scoped_refptr<PrefStore>& extension_prefs,
                     bool async) {
   policy::BrowserPolicyConnector* policy_connector =
@@ skipping 13 matching lines @@
   factory->set_async(async);
   factory->set_extension_prefs(extension_prefs);
   factory->set_command_line_prefs(make_scoped_refptr(
       new ChromeCommandLinePrefStore(base::CommandLine::ForCurrentProcess())));
   factory->set_read_error_callback(base::Bind(&HandleReadError, pref_filename));
   factory->set_user_prefs(user_pref_store);
   factory->SetPrefModelAssociatorClient(
       ChromePrefModelAssociatorClient::GetInstance());
 }
 
+class ResetOnLoadObserverImpl : public prefs::mojom::ResetOnLoadObserver {
+ public:
+  explicit ResetOnLoadObserverImpl(const base::FilePath& profile_path)
+      : profile_path_(profile_path) {}
+
+  void OnResetOnLoad() override {
+    // A StartSyncFlare used to kick sync early in case of a reset event. This
+    // is done since sync may bring back the user's server value post-reset
+    // which could potentially cause a "settings flash" between the factory
+    // default and the re-instantiated server value. Starting sync ASAP
+    // minimizes the window before the server value is re-instantiated (this
+    // window can otherwise be as long as 10 seconds by default).
+    sync_start_util::GetFlareForSyncableService(profile_path_)
+        .Run(syncer::PREFERENCES);
+  }
+
+ private:
+  const base::FilePath profile_path_;
+
+  DISALLOW_COPY_AND_ASSIGN(ResetOnLoadObserverImpl);
+};
+
 }  // namespace
 
 namespace chrome_prefs {
 
 namespace internals {
 
 // Group modifications should be reflected in first_run_browsertest.cc and
 // pref_hash_browsertest.cc.
 const char kSettingsEnforcementTrialName[] = "SettingsEnforcement";
 const char kSettingsEnforcementGroupNoEnforcement[] = "no_enforcement";
@@ skipping 16 matching lines @@
                  NULL,  // supervised_user_settings
                  new JsonPrefStore(pref_filename, pref_io_task_runner,
                                    std::unique_ptr<PrefFilter>()),
                  NULL,  // extension_prefs
                  async);
   return factory.Create(pref_registry.get());
 }
 
 std::unique_ptr<sync_preferences::PrefServiceSyncable> CreateProfilePrefs(
     const base::FilePath& profile_path,
-    base::SequencedTaskRunner* pref_io_task_runner,
-    prefs::mojom::TrackedPreferenceValidationDelegate* validation_delegate,
+    prefs::mojom::TrackedPreferenceValidationDelegatePtr validation_delegate,
     policy::PolicyService* policy_service,
     SupervisedUserSettingsService* supervised_user_settings,
     const scoped_refptr<PrefStore>& extension_prefs,
     const scoped_refptr<user_prefs::PrefRegistrySyncable>& pref_registry,
     bool async,
     service_manager::Connector* connector) {
   TRACE_EVENT0("browser", "chrome_prefs::CreateProfilePrefs");
   SCOPED_UMA_HISTOGRAM_TIMER("PrefService.CreateProfilePrefsTime");
 
-  // A StartSyncFlare used to kick sync early in case of a reset event. This is
-  // done since sync may bring back the user's server value post-reset which
-  // could potentially cause a "settings flash" between the factory default and
-  // the re-instantiated server value. Starting sync ASAP minimizes the window
-  // before the server value is re-instantiated (this window can otherwise be
-  // as long as 10 seconds by default).
-  const base::Closure start_sync_flare_for_prefs =
-      base::Bind(sync_start_util::GetFlareForSyncableService(profile_path),
-                 syncer::PREFERENCES);
-
+  prefs::mojom::ResetOnLoadObserverPtr reset_on_load_observer;
+  mojo::MakeStrongBinding(
+      base::MakeUnique<ResetOnLoadObserverImpl>(profile_path),
+      mojo::MakeRequest(&reset_on_load_observer));

[gab, 2017/04/03 16:11:17]

General Mojo question (since I can't find documentation for this either): what
does this do? And how would I know to write this as a non-mojo guru?

i.e. why aren't we just passing
base::MakeUnique<ResetOnLoadObserverImpl>(profile_path) in
CreateProfilePrefStore() below?

[Sam McNally, 2017/04/04 03:24:49]

There are docs for this now:
https://chromium.googlesource.com/chromium/src/+/master/mojo/public/cpp/bindi....
In particular, this is the pattern described in
https://chromium.googlesource.com/chromium/src/+/master/mojo/public/cpp/bindi....

We want to pass to the service the client end of a mojo pipe pointing at the
ResetOnLoadObserverImpl (in this case using a StrongBinding to manage the impl
lifetime).

[gab, 2017/04/04 20:59:51]

Awesome, thanks!

PS: Guess this is easy now as this OnResetOnLoad() override makes a static call,
but lifetime would be more complex if that object needed to  be teared down
before something else it owned, right? What would you do then? Refcount its
state?

[Sam McNally, 2017/04/05 00:44:30]

Probably something like how it was managed before: ProfileImpl would own both
the implementation and a Binding. Then when the shared state goes away, the mojo
connection would break.

   sync_preferences::PrefServiceSyncableFactory factory;
   scoped_refptr<PersistentPrefStore> user_pref_store(
       CreateProfilePrefStoreManager(profile_path)
-          ->CreateProfilePrefStore(
-              pref_io_task_runner, start_sync_flare_for_prefs,
-              validation_delegate, connector, pref_registry));
+          ->CreateProfilePrefStore(content::BrowserThread::GetBlockingPool(),
+                                   std::move(reset_on_load_observer),
+                                   std::move(validation_delegate), connector,
+                                   pref_registry));
   PrepareFactory(&factory, profile_path, policy_service,
                  supervised_user_settings, user_pref_store, extension_prefs,
                  async);
   std::unique_ptr<sync_preferences::PrefServiceSyncable> pref_service =
       factory.CreateSyncable(pref_registry.get(), connector);
 
   return pref_service;
 }
 
 void DisableDomainCheckForTesting() {
@@ skipping 15 matching lines @@
 
 void ClearResetTime(Profile* profile) {
   ProfilePrefStoreManager::ClearResetTime(profile->GetPrefs());
 }
 
 void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
   ProfilePrefStoreManager::RegisterProfilePrefs(registry);
 }
 
 }  // namespace chrome_prefs