Migrate Extensions code to Task Scheduler API

chrome/browser/extensions/api/storage/settings_sync_unittest.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 <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ptr_util.h"
-#include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/extensions/api/storage/settings_sync_util.h"
 #include "chrome/browser/extensions/api/storage/sync_value_store_cache.h"
 #include "chrome/browser/extensions/api/storage/syncable_settings_storage.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/sync/model/sync_change_processor.h"
 #include "components/sync/model/sync_change_processor_wrapper_for_test.h"
 #include "components/sync/model/sync_error_factory.h"
 #include "components/sync/model/sync_error_factory_mock.h"
 #include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_utils.h"
+#include "extensions/browser/api/storage/backend_task_runner.h"
 #include "extensions/browser/api/storage/settings_test_util.h"
 #include "extensions/browser/api/storage/storage_frontend.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/event_router_factory.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/mock_extension_system.h"
 #include "extensions/browser/value_store/test_value_store_factory.h"
 #include "extensions/browser/value_store/testing_value_store.h"
 #include "extensions/common/manifest.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 159 matching lines @@
                                   &MockExtensionSystemFactoryFunction);
 
     EventRouterFactory::GetInstance()->SetTestingFactory(profile_.get(),
                                                          &BuildEventRouter);
   }
 
   void TearDown() override {
     frontend_.reset();
     profile_.reset();
     // Execute any pending deletion tasks.
-    base::RunLoop().RunUntilIdle();
+    content::RunAllBlockingPoolTasksUntilIdle();
   }
 
  protected:
   // Adds a record of an extension or app to the extension service, then returns
   // its storage area.
   ValueStore* AddExtensionAndGetStorage(
       const std::string& id, Manifest::Type type) {
     scoped_refptr<const Extension> extension =
         util::AddExtensionWithId(profile_.get(), id, type);
     return util::GetStorage(extension, frontend_.get());
   }
 
   // Gets the syncer::SyncableService for the given sync type.
   syncer::SyncableService* GetSyncableService(syncer::ModelType model_type) {
-    base::RunLoop().RunUntilIdle();
     SyncValueStoreCache* sync_cache = static_cast<SyncValueStoreCache*>(
         frontend_->GetValueStoreCache(settings_namespace::SYNC));
     return sync_cache->GetSyncableService(model_type);
   }
 
   // Gets all the sync data from the SyncableService for a sync type as a map
   // from extension id to its sync data.
   SettingSyncDataMultimap GetAllSyncData(syncer::ModelType model_type) {
     syncer::SyncDataList as_list =
         GetSyncableService(model_type)->GetAllSyncData(model_type);
@@ skipping 10 matching lines @@
     return as_map;
   }
 
   // This class uses it's TestingValueStore in such a way that it always mints
   // new TestingValueStore instances.
   TestingValueStore* GetExisting(const ExtensionId& extension_id) {
     return static_cast<TestingValueStore*>(
         storage_factory_->GetExisting(extension_id));
   }
 
+  template <typename Func>
+  static void RunFunc(Func func) {
+    func();
+  }
+
+  template <typename Func>
+  void PostOnBackendSequenceAndWait(const tracked_objects::Location& from_here,

[Devlin, 2017/07/12 22:58:00]

Heh, clever. :)

[stanisc, 2017/07/12 23:42:49]

After failing to use lambda directly with base::Bind I stole this idea from
LambdaBinder in sync_method_unittest.cc.

+                                    Func func) {
+    GetBackendTaskRunner()->PostTask(
+        from_here, base::Bind(&ExtensionSettingsSyncTest::RunFunc<Func>, func));
+    content::RunAllBlockingPoolTasksUntilIdle();
+  }
+
   // Needed so that the DCHECKs for running on FILE or UI threads pass.
   content::TestBrowserThreadBundle test_browser_thread_bundle_;
 
   base::ScopedTempDir temp_dir_;
   std::unique_ptr<TestingProfile> profile_;
   std::unique_ptr<StorageFrontend> frontend_;
   scoped_refptr<TestValueStoreFactory> storage_factory_;
   std::unique_ptr<MockSyncChangeProcessor> sync_processor_;
   std::unique_ptr<syncer::SyncChangeProcessorWrapperForTest>
       sync_processor_wrapper_;
 };
 
 // Get a semblance of coverage for both EXTENSION_SETTINGS and APP_SETTINGS
 // sync by roughly alternative which one to test.
 
 TEST_F(ExtensionSettingsSyncTest, NoDataDoesNotInvokeSync) {
   syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Manifest::Type type = Manifest::TYPE_EXTENSION;
 
-  EXPECT_EQ(0u, GetAllSyncData(model_type).size());
+  PostOnBackendSequenceAndWait(FROM_HERE, [&, this]() {
+    EXPECT_EQ(0u, GetAllSyncData(model_type).size());
+  });
 
   // Have one extension created before sync is set up, the other created after.
   AddExtensionAndGetStorage("s1", type);
-  EXPECT_EQ(0u, GetAllSyncData(model_type).size());
 
-  GetSyncableService(model_type)
-      ->MergeDataAndStartSyncing(
-          model_type, syncer::SyncDataList(),
-          std::move(sync_processor_wrapper_),
-          base::MakeUnique<syncer::SyncErrorFactoryMock>());
+  PostOnBackendSequenceAndWait(FROM_HERE, [&, this]() {
+    EXPECT_EQ(0u, GetAllSyncData(model_type).size());
+
+    GetSyncableService(model_type)
+        ->MergeDataAndStartSyncing(
+            model_type, syncer::SyncDataList(),
+            std::move(sync_processor_wrapper_),
+            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+  });
 
   AddExtensionAndGetStorage("s2", type);
-  EXPECT_EQ(0u, GetAllSyncData(model_type).size());
 
-  GetSyncableService(model_type)->StopSyncing(model_type);
+  PostOnBackendSequenceAndWait(FROM_HERE, [&, this]() {
+    EXPECT_EQ(0u, GetAllSyncData(model_type).size());
 
-  EXPECT_EQ(0u, sync_processor_->changes().size());
-  EXPECT_EQ(0u, GetAllSyncData(model_type).size());
+    GetSyncableService(model_type)->StopSyncing(model_type);
+
+    EXPECT_EQ(0u, sync_processor_->changes().size());
+    EXPECT_EQ(0u, GetAllSyncData(model_type).size());
+  });
 }
 
 TEST_F(ExtensionSettingsSyncTest, InSyncDataDoesNotInvokeSync) {
   syncer::ModelType model_type = syncer::APP_SETTINGS;
   Manifest::Type type = Manifest::TYPE_LEGACY_PACKAGED_APP;
 
   base::Value value1("fooValue");
   base::ListValue value2;
   value2.AppendString("barValue");
 
   ValueStore* storage1 = AddExtensionAndGetStorage("s1", type);
   ValueStore* storage2 = AddExtensionAndGetStorage("s2", type);
 
-  storage1->Set(DEFAULTS, "foo", value1);
-  storage2->Set(DEFAULTS, "bar", value2);
+  PostOnBackendSequenceAndWait(FROM_HERE, [&, this]() {
+    storage1->Set(DEFAULTS, "foo", value1);
+    storage2->Set(DEFAULTS, "bar", value2);
 
-  SettingSyncDataMultimap all_sync_data = GetAllSyncData(model_type);
-  EXPECT_EQ(2u, all_sync_data.size());
-  EXPECT_EQ(1u, all_sync_data["s1"]->size());
-  EXPECT_PRED_FORMAT2(ValuesEq, &value1, &(*all_sync_data["s1"])[0]->value());
-  EXPECT_EQ(1u, all_sync_data["s2"]->size());
-  EXPECT_PRED_FORMAT2(ValuesEq, &value2, &(*all_sync_data["s2"])[0]->value());
+    SettingSyncDataMultimap all_sync_data = GetAllSyncData(model_type);
+    EXPECT_EQ(2u, all_sync_data.size());
+    EXPECT_EQ(1u, all_sync_data["s1"]->size());
+    EXPECT_PRED_FORMAT2(ValuesEq, &value1, &(*all_sync_data["s1"])[0]->value());
+    EXPECT_EQ(1u, all_sync_data["s2"]->size());
+    EXPECT_PRED_FORMAT2(ValuesEq, &value2, &(*all_sync_data["s2"])[0]->value());
 
-  syncer::SyncDataList sync_data;
-  sync_data.push_back(settings_sync_util::CreateData(
-      "s1", "foo", value1, model_type));
-  sync_data.push_back(settings_sync_util::CreateData(
-      "s2", "bar", value2, model_type));
+    syncer::SyncDataList sync_data;
+    sync_data.push_back(
+        settings_sync_util::CreateData("s1", "foo", value1, model_type));
+    sync_data.push_back(
+        settings_sync_util::CreateData("s2", "bar", value2, model_type));
 
-  GetSyncableService(model_type)
-      ->MergeDataAndStartSyncing(
-          model_type, sync_data, std::move(sync_processor_wrapper_),
-          base::MakeUnique<syncer::SyncErrorFactoryMock>());
+    GetSyncableService(model_type)
+        ->MergeDataAndStartSyncing(
+            model_type, sync_data, std::move(sync_processor_wrapper_),
+            base::MakeUnique<syncer::SyncErrorFactoryMock>());
 
-  // Already in sync, so no changes.
-  EXPECT_EQ(0u, sync_processor_->changes().size());
+    // Already in sync, so no changes.
+    EXPECT_EQ(0u, sync_processor_->changes().size());
 
-  // Regression test: not-changing the synced value shouldn't result in a sync
-  // change, and changing the synced value should result in an update.
-  storage1->Set(DEFAULTS, "foo", value1);
-  EXPECT_EQ(0u, sync_processor_->changes().size());
+    // Regression test: not-changing the synced value shouldn't result in a sync
+    // change, and changing the synced value should result in an update.
+    storage1->Set(DEFAULTS, "foo", value1);
+    EXPECT_EQ(0u, sync_processor_->changes().size());
 
-  storage1->Set(DEFAULTS, "foo", value2);
-  EXPECT_EQ(1u, sync_processor_->changes().size());
-  SettingSyncData* change = sync_processor_->GetOnlyChange("s1", "foo");
-  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change->change_type());
-  EXPECT_TRUE(value2.Equals(&change->value()));
+    storage1->Set(DEFAULTS, "foo", value2);
+    EXPECT_EQ(1u, sync_processor_->changes().size());
+    SettingSyncData* change = sync_processor_->GetOnlyChange("s1", "foo");
+    EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change->change_type());
+    EXPECT_TRUE(value2.Equals(&change->value()));
 
-  GetSyncableService(model_type)->StopSyncing(model_type);
+    GetSyncableService(model_type)->StopSyncing(model_type);
+  });
 }
 
 TEST_F(ExtensionSettingsSyncTest, LocalDataWithNoSyncDataIsPushedToSync) {
   syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Manifest::Type type = Manifest::TYPE_EXTENSION;
 
   base::Value value1("fooValue");
   base::ListValue value2;
   value2.AppendString("barValue");
 
   ValueStore* storage1 = AddExtensionAndGetStorage("s1", type);
   ValueStore* storage2 = AddExtensionAndGetStorage("s2", type);
 
-  storage1->Set(DEFAULTS, "foo", value1);
-  storage2->Set(DEFAULTS, "bar", value2);
+  PostOnBackendSequenceAndWait(FROM_HERE, [&, this]() {
+    storage1->Set(DEFAULTS, "foo", value1);
+    storage2->Set(DEFAULTS, "bar", value2);
 
-  GetSyncableService(model_type)
-      ->MergeDataAndStartSyncing(
-          model_type, syncer::SyncDataList(),
-          std::move(sync_processor_wrapper_),
-          base::MakeUnique<syncer::SyncErrorFactoryMock>());
+    GetSyncableService(model_type)
+        ->MergeDataAndStartSyncing(
+            model_type, syncer::SyncDataList(),
+            std::move(sync_processor_wrapper_),
+            base::MakeUnique<syncer::SyncErrorFactoryMock>());
 
-  // All settings should have been pushed to sync.
-  EXPECT_EQ(2u, sync_processor_->changes().size());
-  SettingSyncData* change = sync_processor_->GetOnlyChange("s1", "foo");
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change->change_type());
-  EXPECT_TRUE(value1.Equals(&change->value()));
-  change = sync_processor_->GetOnlyChange("s2", "bar");
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change->change_type());
-  EXPECT_TRUE(value2.Equals(&change->value()));
+    // All settings should have been pushed to sync.
+    EXPECT_EQ(2u, sync_processor_->changes().size());
+    SettingSyncData* change = sync_processor_->GetOnlyChange("s1", "foo");
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change->change_type());
+    EXPECT_TRUE(value1.Equals(&change->value()));
+    change = sync_processor_->GetOnlyChange("s2", "bar");
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change->change_type());
+    EXPECT_TRUE(value2.Equals(&change->value()));
 
-  GetSyncableService(model_type)->StopSyncing(model_type);
+    GetSyncableService(model_type)->StopSyncing(model_type);
+  });
 }
 
 TEST_F(ExtensionSettingsSyncTest, AnySyncDataOverwritesLocalData) {
   syncer::ModelType model_type = syncer::APP_SETTINGS;
   Manifest::Type type = Manifest::TYPE_LEGACY_PACKAGED_APP;
 
   base::Value value1("fooValue");
   base::ListValue value2;
   value2.AppendString("barValue");
 
   // Maintain dictionaries mirrored to the expected values of the settings in
   // each storage area.
   base::DictionaryValue expected1, expected2;
 
   // Pre-populate one of the storage areas.
   ValueStore* storage1 = AddExtensionAndGetStorage("s1", type);
-  storage1->Set(DEFAULTS, "overwriteMe", value1);
 
-  syncer::SyncDataList sync_data;
-  sync_data.push_back(settings_sync_util::CreateData(
-      "s1", "foo", value1, model_type));
-  sync_data.push_back(settings_sync_util::CreateData(
-      "s2", "bar", value2, model_type));
-  GetSyncableService(model_type)
-      ->MergeDataAndStartSyncing(
-          model_type, sync_data, std::move(sync_processor_wrapper_),
-          base::MakeUnique<syncer::SyncErrorFactoryMock>());
-  expected1.Set("foo", value1.CreateDeepCopy());
-  expected2.Set("bar", value2.CreateDeepCopy());
+  PostOnBackendSequenceAndWait(FROM_HERE, [&, this]() {
+    storage1->Set(DEFAULTS, "overwriteMe", value1);
+
+    syncer::SyncDataList sync_data;
+    sync_data.push_back(
+        settings_sync_util::CreateData("s1", "foo", value1, model_type));
+    sync_data.push_back(
+        settings_sync_util::CreateData("s2", "bar", value2, model_type));
+    GetSyncableService(model_type)
+        ->MergeDataAndStartSyncing(
+            model_type, sync_data, std::move(sync_processor_wrapper_),
+            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+    expected1.Set("foo", value1.CreateDeepCopy());
+    expected2.Set("bar", value2.CreateDeepCopy());
+  });
 
   ValueStore* storage2 = AddExtensionAndGetStorage("s2", type);
 
-  // All changes should be local, so no sync changes.
-  EXPECT_EQ(0u, sync_processor_->changes().size());
+  PostOnBackendSequenceAndWait(FROM_HERE, [&, this]() {
+    // All changes should be local, so no sync changes.
+    EXPECT_EQ(0u, sync_processor_->changes().size());
 
-  // Sync settings should have been pushed to local settings.
-  EXPECT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
-  EXPECT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
+    // Sync settings should have been pushed to local settings.
+    EXPECT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
+    EXPECT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
 
-  GetSyncableService(model_type)->StopSyncing(model_type);
+    GetSyncableService(model_type)->StopSyncing(model_type);
+  });
 }
 
 TEST_F(ExtensionSettingsSyncTest, ProcessSyncChanges) {
   syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Manifest::Type type = Manifest::TYPE_EXTENSION;
 
   base::Value value1("fooValue");
   base::ListValue value2;
   value2.AppendString("barValue");
 
-  // Maintain dictionaries mirrored to the expected values of the settings in

[Devlin, 2017/07/12 22:58:00]

Reitveld's struggling with some of these diffs - are these all copy-paste-git cl
format?

[stanisc, 2017/07/12 23:42:49]

Yes, more or less. Some of code blocks had to be moved to be inside or outside
of PostOnBackendSequenceAndWait scope via copy-paste. Other than that and  and
indenting the code, and running 'git cl format' I didn't do any changes.

-  // each storage area.
-  base::DictionaryValue expected1, expected2;
-
   // Make storage1 initialised from local data, storage2 initialised from sync.
   ValueStore* storage1 = AddExtensionAndGetStorage("s1", type);
   ValueStore* storage2 = AddExtensionAndGetStorage("s2", type);
 
-  storage1->Set(DEFAULTS, "foo", value1);
-  expected1.Set("foo", value1.CreateDeepCopy());
+  PostOnBackendSequenceAndWait(FROM_HERE, [&, this]() {
+    // Maintain dictionaries mirrored to the expected values of the settings in
+    // each storage area.
+    base::DictionaryValue expected1, expected2;
 
-  syncer::SyncDataList sync_data;
-  sync_data.push_back(settings_sync_util::CreateData(
-      "s2", "bar", value2, model_type));
+    storage1->Set(DEFAULTS, "foo", value1);
+    expected1.Set("foo", value1.CreateDeepCopy());
 
-  GetSyncableService(model_type)
-      ->MergeDataAndStartSyncing(
-          model_type, sync_data, std::move(sync_processor_wrapper_),
-          base::MakeUnique<syncer::SyncErrorFactoryMock>());
-  expected2.Set("bar", value2.CreateDeepCopy());
+    syncer::SyncDataList sync_data;
+    sync_data.push_back(
+        settings_sync_util::CreateData("s2", "bar", value2, model_type));
 
-  // Make sync add some settings.
-  syncer::SyncChangeList change_list;
-  change_list.push_back(settings_sync_util::CreateAdd(
-      "s1", "bar", value2, model_type));
-  change_list.push_back(settings_sync_util::CreateAdd(
-      "s2", "foo", value1, model_type));
-  GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
-  expected1.Set("bar", value2.CreateDeepCopy());
-  expected2.Set("foo", value1.CreateDeepCopy());
+    GetSyncableService(model_type)
+        ->MergeDataAndStartSyncing(
+            model_type, sync_data, std::move(sync_processor_wrapper_),
+            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+    expected2.Set("bar", value2.CreateDeepCopy());
 
-  EXPECT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
-  EXPECT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
+    // Make sync add some settings.
+    syncer::SyncChangeList change_list;
+    change_list.push_back(
+        settings_sync_util::CreateAdd("s1", "bar", value2, model_type));
+    change_list.push_back(
+        settings_sync_util::CreateAdd("s2", "foo", value1, model_type));
+    GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
+    expected1.Set("bar", value2.CreateDeepCopy());
+    expected2.Set("foo", value1.CreateDeepCopy());
 
-  // Make sync update some settings, storage1 the new setting, storage2 the
-  // initial setting.
-  change_list.clear();
-  change_list.push_back(settings_sync_util::CreateUpdate(
-      "s1", "bar", value2, model_type));
-  change_list.push_back(settings_sync_util::CreateUpdate(
-      "s2", "bar", value1, model_type));
-  GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
-  expected1.Set("bar", value2.CreateDeepCopy());
-  expected2.Set("bar", value1.CreateDeepCopy());
+    EXPECT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
+    EXPECT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
 
-  EXPECT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
-  EXPECT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
+    // Make sync update some settings, storage1 the new setting, storage2 the
+    // initial setting.
+    change_list.clear();
+    change_list.push_back(
+        settings_sync_util::CreateUpdate("s1", "bar", value2, model_type));
+    change_list.push_back(
+        settings_sync_util::CreateUpdate("s2", "bar", value1, model_type));
+    GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
+    expected1.Set("bar", value2.CreateDeepCopy());
+    expected2.Set("bar", value1.CreateDeepCopy());
 
-  // Make sync remove some settings, storage1 the initial setting, storage2 the
-  // new setting.
-  change_list.clear();
-  change_list.push_back(settings_sync_util::CreateDelete(
-      "s1", "foo", model_type));
-  change_list.push_back(settings_sync_util::CreateDelete(
-      "s2", "foo", model_type));
-  GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
-  expected1.Remove("foo", NULL);
-  expected2.Remove("foo", NULL);
+    EXPECT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
+    EXPECT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
 
-  EXPECT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
-  EXPECT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
+    // Make sync remove some settings, storage1 the initial setting, storage2
+    // the new setting.
+    change_list.clear();
+    change_list.push_back(
+        settings_sync_util::CreateDelete("s1", "foo", model_type));
+    change_list.push_back(
+        settings_sync_util::CreateDelete("s2", "foo", model_type));
+    GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
+    expected1.Remove("foo", NULL);
+    expected2.Remove("foo", NULL);
 
-  GetSyncableService(model_type)->StopSyncing(model_type);
+    EXPECT_PRED_FORMAT2(SettingsEq, expected1, storage1->Get());
+    EXPECT_PRED_FORMAT2(SettingsEq, expected2, storage2->Get());
+
+    GetSyncableService(model_type)->StopSyncing(model_type);
+  });
 }
 
 TEST_F(ExtensionSettingsSyncTest, PushToSync) {
   syncer::ModelType model_type = syncer::APP_SETTINGS;
   Manifest::Type type = Manifest::TYPE_LEGACY_PACKAGED_APP;
 
   base::Value value1("fooValue");
   base::ListValue value2;
   value2.AppendString("barValue");
 
   // Make storage1/2 initialised from local data, storage3/4 initialised from
   // sync.
   ValueStore* storage1 = AddExtensionAndGetStorage("s1", type);
   ValueStore* storage2 = AddExtensionAndGetStorage("s2", type);
   ValueStore* storage3 = AddExtensionAndGetStorage("s3", type);
   ValueStore* storage4 = AddExtensionAndGetStorage("s4", type);
 
-  storage1->Set(DEFAULTS, "foo", value1);
-  storage2->Set(DEFAULTS, "foo", value1);
+  PostOnBackendSequenceAndWait(FROM_HERE, [&, this]() {
+    storage1->Set(DEFAULTS, "foo", value1);
+    storage2->Set(DEFAULTS, "foo", value1);
 
-  syncer::SyncDataList sync_data;
-  sync_data.push_back(settings_sync_util::CreateData(
-      "s3", "bar", value2, model_type));
-  sync_data.push_back(settings_sync_util::CreateData(
-      "s4", "bar", value2, model_type));
+    syncer::SyncDataList sync_data;
+    sync_data.push_back(
+        settings_sync_util::CreateData("s3", "bar", value2, model_type));
+    sync_data.push_back(
+        settings_sync_util::CreateData("s4", "bar", value2, model_type));
 
-  GetSyncableService(model_type)
-      ->MergeDataAndStartSyncing(
-          model_type, sync_data, std::move(sync_processor_wrapper_),
-          base::MakeUnique<syncer::SyncErrorFactoryMock>());
+    GetSyncableService(model_type)
+        ->MergeDataAndStartSyncing(
+            model_type, sync_data, std::move(sync_processor_wrapper_),
+            base::MakeUnique<syncer::SyncErrorFactoryMock>());
 
-  // Add something locally.
-  storage1->Set(DEFAULTS, "bar", value2);
-  storage2->Set(DEFAULTS, "bar", value2);
-  storage3->Set(DEFAULTS, "foo", value1);
-  storage4->Set(DEFAULTS, "foo", value1);
+    // Add something locally.
+    storage1->Set(DEFAULTS, "bar", value2);
+    storage2->Set(DEFAULTS, "bar", value2);
+    storage3->Set(DEFAULTS, "foo", value1);
+    storage4->Set(DEFAULTS, "foo", value1);
 
-  SettingSyncData* change = sync_processor_->GetOnlyChange("s1", "bar");
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change->change_type());
-  EXPECT_TRUE(value2.Equals(&change->value()));
-  sync_processor_->GetOnlyChange("s2", "bar");
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change->change_type());
-  EXPECT_TRUE(value2.Equals(&change->value()));
-  change = sync_processor_->GetOnlyChange("s3", "foo");
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change->change_type());
-  EXPECT_TRUE(value1.Equals(&change->value()));
-  change = sync_processor_->GetOnlyChange("s4", "foo");
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change->change_type());
-  EXPECT_TRUE(value1.Equals(&change->value()));
+    SettingSyncData* change = sync_processor_->GetOnlyChange("s1", "bar");
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change->change_type());
+    EXPECT_TRUE(value2.Equals(&change->value()));
+    sync_processor_->GetOnlyChange("s2", "bar");
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change->change_type());
+    EXPECT_TRUE(value2.Equals(&change->value()));
+    change = sync_processor_->GetOnlyChange("s3", "foo");
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change->change_type());
+    EXPECT_TRUE(value1.Equals(&change->value()));
+    change = sync_processor_->GetOnlyChange("s4", "foo");
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD, change->change_type());
+    EXPECT_TRUE(value1.Equals(&change->value()));
 
-  // Change something locally, storage1/3 the new setting and storage2/4 the
-  // initial setting, for all combinations of local vs sync intialisation and
-  // new vs initial.
-  sync_processor_->ClearChanges();
-  storage1->Set(DEFAULTS, "bar", value1);
-  storage2->Set(DEFAULTS, "foo", value2);
-  storage3->Set(DEFAULTS, "bar", value1);
-  storage4->Set(DEFAULTS, "foo", value2);
+    // Change something locally, storage1/3 the new setting and storage2/4 the
+    // initial setting, for all combinations of local vs sync intialisation and
+    // new vs initial.
+    sync_processor_->ClearChanges();
+    storage1->Set(DEFAULTS, "bar", value1);
+    storage2->Set(DEFAULTS, "foo", value2);
+    storage3->Set(DEFAULTS, "bar", value1);
+    storage4->Set(DEFAULTS, "foo", value2);
 
-  change = sync_processor_->GetOnlyChange("s1", "bar");
-  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change->change_type());
-  EXPECT_TRUE(value1.Equals(&change->value()));
-  change = sync_processor_->GetOnlyChange("s2", "foo");
-  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change->change_type());
-  EXPECT_TRUE(value2.Equals(&change->value()));
-  change = sync_processor_->GetOnlyChange("s3", "bar");
-  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change->change_type());
-  EXPECT_TRUE(value1.Equals(&change->value()));
-  change = sync_processor_->GetOnlyChange("s4", "foo");
-  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change->change_type());
-  EXPECT_TRUE(value2.Equals(&change->value()));
+    change = sync_processor_->GetOnlyChange("s1", "bar");
+    EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change->change_type());
+    EXPECT_TRUE(value1.Equals(&change->value()));
+    change = sync_processor_->GetOnlyChange("s2", "foo");
+    EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change->change_type());
+    EXPECT_TRUE(value2.Equals(&change->value()));
+    change = sync_processor_->GetOnlyChange("s3", "bar");
+    EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change->change_type());
+    EXPECT_TRUE(value1.Equals(&change->value()));
+    change = sync_processor_->GetOnlyChange("s4", "foo");
+    EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE, change->change_type());
+    EXPECT_TRUE(value2.Equals(&change->value()));
 
-  // Remove something locally, storage1/3 the new setting and storage2/4 the
-  // initial setting, for all combinations of local vs sync intialisation and
-  // new vs initial.
-  sync_processor_->ClearChanges();
-  storage1->Remove("foo");
-  storage2->Remove("bar");
-  storage3->Remove("foo");
-  storage4->Remove("bar");
+    // Remove something locally, storage1/3 the new setting and storage2/4 the
+    // initial setting, for all combinations of local vs sync intialisation and
+    // new vs initial.
+    sync_processor_->ClearChanges();
+    storage1->Remove("foo");
+    storage2->Remove("bar");
+    storage3->Remove("foo");
+    storage4->Remove("bar");
 
-  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
-            sync_processor_->GetOnlyChange("s1", "foo")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
-            sync_processor_->GetOnlyChange("s2", "bar")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
-            sync_processor_->GetOnlyChange("s3", "foo")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
-            sync_processor_->GetOnlyChange("s4", "bar")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
+              sync_processor_->GetOnlyChange("s1", "foo")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
+              sync_processor_->GetOnlyChange("s2", "bar")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
+              sync_processor_->GetOnlyChange("s3", "foo")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
+              sync_processor_->GetOnlyChange("s4", "bar")->change_type());
 
-  // Remove some nonexistent settings.
-  sync_processor_->ClearChanges();
-  storage1->Remove("foo");
-  storage2->Remove("bar");
-  storage3->Remove("foo");
-  storage4->Remove("bar");
+    // Remove some nonexistent settings.
+    sync_processor_->ClearChanges();
+    storage1->Remove("foo");
+    storage2->Remove("bar");
+    storage3->Remove("foo");
+    storage4->Remove("bar");
 
-  EXPECT_EQ(0u, sync_processor_->changes().size());
+    EXPECT_EQ(0u, sync_processor_->changes().size());
 
-  // Clear the rest of the settings.  Add the removed ones back first so that
-  // more than one setting is cleared.
-  storage1->Set(DEFAULTS, "foo", value1);
-  storage2->Set(DEFAULTS, "bar", value2);
-  storage3->Set(DEFAULTS, "foo", value1);
-  storage4->Set(DEFAULTS, "bar", value2);
+    // Clear the rest of the settings.  Add the removed ones back first so that
+    // more than one setting is cleared.
+    storage1->Set(DEFAULTS, "foo", value1);
+    storage2->Set(DEFAULTS, "bar", value2);
+    storage3->Set(DEFAULTS, "foo", value1);
+    storage4->Set(DEFAULTS, "bar", value2);
 
-  sync_processor_->ClearChanges();
-  storage1->Clear();
-  storage2->Clear();
-  storage3->Clear();
-  storage4->Clear();
+    sync_processor_->ClearChanges();
+    storage1->Clear();
+    storage2->Clear();
+    storage3->Clear();
+    storage4->Clear();
 
-  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
-            sync_processor_->GetOnlyChange("s1", "foo")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
-            sync_processor_->GetOnlyChange("s1", "bar")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
-            sync_processor_->GetOnlyChange("s2", "foo")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
-            sync_processor_->GetOnlyChange("s2", "bar")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
-            sync_processor_->GetOnlyChange("s3", "foo")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
-            sync_processor_->GetOnlyChange("s3", "bar")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
-            sync_processor_->GetOnlyChange("s4", "foo")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
-            sync_processor_->GetOnlyChange("s4", "bar")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
+              sync_processor_->GetOnlyChange("s1", "foo")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
+              sync_processor_->GetOnlyChange("s1", "bar")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
+              sync_processor_->GetOnlyChange("s2", "foo")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
+              sync_processor_->GetOnlyChange("s2", "bar")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
+              sync_processor_->GetOnlyChange("s3", "foo")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
+              sync_processor_->GetOnlyChange("s3", "bar")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
+              sync_processor_->GetOnlyChange("s4", "foo")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_DELETE,
+              sync_processor_->GetOnlyChange("s4", "bar")->change_type());
 
-  GetSyncableService(model_type)->StopSyncing(model_type);
+    GetSyncableService(model_type)->StopSyncing(model_type);
+  });
 }
 
 TEST_F(ExtensionSettingsSyncTest, ExtensionAndAppSettingsSyncSeparately) {
   base::Value value1("fooValue");
   base::ListValue value2;
   value2.AppendString("barValue");
 
   // storage1 is an extension, storage2 is an app.
   ValueStore* storage1 = AddExtensionAndGetStorage(
       "s1", Manifest::TYPE_EXTENSION);
   ValueStore* storage2 = AddExtensionAndGetStorage(
       "s2", Manifest::TYPE_LEGACY_PACKAGED_APP);
 
-  storage1->Set(DEFAULTS, "foo", value1);
-  storage2->Set(DEFAULTS, "bar", value2);
+  PostOnBackendSequenceAndWait(FROM_HERE, [&, this]() {
+    storage1->Set(DEFAULTS, "foo", value1);
+    storage2->Set(DEFAULTS, "bar", value2);
 
-  SettingSyncDataMultimap extension_sync_data =
-      GetAllSyncData(syncer::EXTENSION_SETTINGS);
-  EXPECT_EQ(1u, extension_sync_data.size());
-  EXPECT_EQ(1u, extension_sync_data["s1"]->size());
-  EXPECT_PRED_FORMAT2(ValuesEq, &value1,
-                      &(*extension_sync_data["s1"])[0]->value());
+    SettingSyncDataMultimap extension_sync_data =
+        GetAllSyncData(syncer::EXTENSION_SETTINGS);
+    EXPECT_EQ(1u, extension_sync_data.size());
+    EXPECT_EQ(1u, extension_sync_data["s1"]->size());
+    EXPECT_PRED_FORMAT2(ValuesEq, &value1,
+                        &(*extension_sync_data["s1"])[0]->value());
 
-  SettingSyncDataMultimap app_sync_data = GetAllSyncData(syncer::APP_SETTINGS);
-  EXPECT_EQ(1u, app_sync_data.size());
-  EXPECT_EQ(1u, app_sync_data["s2"]->size());
-  EXPECT_PRED_FORMAT2(ValuesEq, &value2, &(*app_sync_data["s2"])[0]->value());
+    SettingSyncDataMultimap app_sync_data =
+        GetAllSyncData(syncer::APP_SETTINGS);
+    EXPECT_EQ(1u, app_sync_data.size());
+    EXPECT_EQ(1u, app_sync_data["s2"]->size());
+    EXPECT_PRED_FORMAT2(ValuesEq, &value2, &(*app_sync_data["s2"])[0]->value());
 
-  // Stop each separately, there should be no changes either time.
-  syncer::SyncDataList sync_data;
-  sync_data.push_back(settings_sync_util::CreateData(
-      "s1", "foo", value1, syncer::EXTENSION_SETTINGS));
+    // Stop each separately, there should be no changes either time.
+    syncer::SyncDataList sync_data;
+    sync_data.push_back(settings_sync_util::CreateData(
+        "s1", "foo", value1, syncer::EXTENSION_SETTINGS));
 
-  GetSyncableService(syncer::EXTENSION_SETTINGS)
-      ->MergeDataAndStartSyncing(
-          syncer::EXTENSION_SETTINGS, sync_data,
-          std::move(sync_processor_wrapper_),
-          base::MakeUnique<syncer::SyncErrorFactoryMock>());
-  GetSyncableService(syncer::EXTENSION_SETTINGS)->
-      StopSyncing(syncer::EXTENSION_SETTINGS);
-  EXPECT_EQ(0u, sync_processor_->changes().size());
+    GetSyncableService(syncer::EXTENSION_SETTINGS)
+        ->MergeDataAndStartSyncing(
+            syncer::EXTENSION_SETTINGS, sync_data,
+            std::move(sync_processor_wrapper_),
+            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+    GetSyncableService(syncer::EXTENSION_SETTINGS)
+        ->StopSyncing(syncer::EXTENSION_SETTINGS);
+    EXPECT_EQ(0u, sync_processor_->changes().size());
 
-  sync_data.clear();
-  sync_data.push_back(settings_sync_util::CreateData(
-      "s2", "bar", value2, syncer::APP_SETTINGS));
+    sync_data.clear();
+    sync_data.push_back(settings_sync_util::CreateData("s2", "bar", value2,
+                                                       syncer::APP_SETTINGS));
 
-  std::unique_ptr<syncer::SyncChangeProcessorWrapperForTest>
-      app_settings_delegate_(
-          new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
-  GetSyncableService(syncer::APP_SETTINGS)
-      ->MergeDataAndStartSyncing(
-          syncer::APP_SETTINGS, sync_data, std::move(app_settings_delegate_),
-          base::MakeUnique<syncer::SyncErrorFactoryMock>());
-  GetSyncableService(syncer::APP_SETTINGS)->
-      StopSyncing(syncer::APP_SETTINGS);
-  EXPECT_EQ(0u, sync_processor_->changes().size());
+    std::unique_ptr<syncer::SyncChangeProcessorWrapperForTest>
+        app_settings_delegate_(new syncer::SyncChangeProcessorWrapperForTest(
+            sync_processor_.get()));
+    GetSyncableService(syncer::APP_SETTINGS)
+        ->MergeDataAndStartSyncing(
+            syncer::APP_SETTINGS, sync_data, std::move(app_settings_delegate_),
+            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+    GetSyncableService(syncer::APP_SETTINGS)->StopSyncing(syncer::APP_SETTINGS);
+    EXPECT_EQ(0u, sync_processor_->changes().size());
+  });
 }
 
 TEST_F(ExtensionSettingsSyncTest, FailingStartSyncingDisablesSync) {
   syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Manifest::Type type = Manifest::TYPE_EXTENSION;
 
   base::Value fooValue("fooValue");
   base::Value barValue("barValue");
 
   // There is a bit of a convoluted method to get storage areas that can fail;
   // hand out TestingValueStore object then toggle them failing/succeeding
   // as necessary.
 
   ValueStore* good = AddExtensionAndGetStorage("good", type);
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
 
-  // Make bad fail for incoming sync changes.
-  GetExisting("bad")->set_status_code(ValueStore::CORRUPTION);
-  {
-    syncer::SyncDataList sync_data;
-    sync_data.push_back(settings_sync_util::CreateData(
+  PostOnBackendSequenceAndWait(FROM_HERE, [&, this]() {
+    // Make bad fail for incoming sync changes.
+    GetExisting("bad")->set_status_code(ValueStore::CORRUPTION);
+    {
+      syncer::SyncDataList sync_data;
+      sync_data.push_back(
+          settings_sync_util::CreateData("good", "foo", fooValue, model_type));
+      sync_data.push_back(
+          settings_sync_util::CreateData("bad", "foo", fooValue, model_type));
+      GetSyncableService(model_type)
+          ->MergeDataAndStartSyncing(
+              model_type, sync_data, std::move(sync_processor_wrapper_),
+              base::MakeUnique<syncer::SyncErrorFactoryMock>());
+    }
+    GetExisting("bad")->set_status_code(ValueStore::OK);
+
+    {
+      base::DictionaryValue dict;
+      dict.Set("foo", fooValue.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
+    }
+    {
+      base::DictionaryValue dict;
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
+    }
+
+    // Changes made to good should be sent to sync, changes from bad shouldn't.
+    sync_processor_->ClearChanges();
+    good->Set(DEFAULTS, "bar", barValue);
+    bad->Set(DEFAULTS, "bar", barValue);
+
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
+              sync_processor_->GetOnlyChange("good", "bar")->change_type());
+    EXPECT_EQ(1u, sync_processor_->changes().size());
+
+    {
+      base::DictionaryValue dict;
+      dict.Set("foo", fooValue.CreateDeepCopy());
+      dict.Set("bar", barValue.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
+    }
+    {
+      base::DictionaryValue dict;
+      dict.Set("bar", barValue.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
+    }
+
+    // Changes received from sync should go to good but not bad (even when it's
+    // not failing).
+    {
+      syncer::SyncChangeList change_list;
+      change_list.push_back(settings_sync_util::CreateUpdate(
+          "good", "foo", barValue, model_type));
+      // (Sending UPDATE here even though it's adding, since that's what the
+      // state of sync is.  In any case, it won't work.)
+      change_list.push_back(
+          settings_sync_util::CreateUpdate("bad", "foo", barValue, model_type));
+      GetSyncableService(model_type)
+          ->ProcessSyncChanges(FROM_HERE, change_list);
+    }
+
+    {
+      base::DictionaryValue dict;
+      dict.Set("foo", barValue.CreateDeepCopy());
+      dict.Set("bar", barValue.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
+    }
+    {
+      base::DictionaryValue dict;
+      dict.Set("bar", barValue.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
+    }
+
+    // Changes made to bad still shouldn't go to sync, even though it didn't
+    // fail last time.
+    sync_processor_->ClearChanges();
+    good->Set(DEFAULTS, "bar", fooValue);
+    bad->Set(DEFAULTS, "bar", fooValue);
+
+    EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
+              sync_processor_->GetOnlyChange("good", "bar")->change_type());
+    EXPECT_EQ(1u, sync_processor_->changes().size());
+
+    {
+      base::DictionaryValue dict;
+      dict.Set("foo", barValue.CreateDeepCopy());
+      dict.Set("bar", fooValue.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
+    }
+    {
+      base::DictionaryValue dict;
+      dict.Set("bar", fooValue.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
+    }
+
+    // Failing ProcessSyncChanges shouldn't go to the storage.
+    GetExisting("bad")->set_status_code(ValueStore::CORRUPTION);
+    {
+      syncer::SyncChangeList change_list;
+      change_list.push_back(settings_sync_util::CreateUpdate(
           "good", "foo", fooValue, model_type));
-    sync_data.push_back(settings_sync_util::CreateData(
-          "bad", "foo", fooValue, model_type));
+      // (Ditto.)
+      change_list.push_back(
+          settings_sync_util::CreateUpdate("bad", "foo", fooValue, model_type));
+      GetSyncableService(model_type)
+          ->ProcessSyncChanges(FROM_HERE, change_list);
+    }
+    GetExisting("bad")->set_status_code(ValueStore::OK);
+
+    {
+      base::DictionaryValue dict;
+      dict.Set("foo", fooValue.CreateDeepCopy());
+      dict.Set("bar", fooValue.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
+    }
+    {
+      base::DictionaryValue dict;
+      dict.Set("bar", fooValue.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
+    }
+
+    // Restarting sync should make bad start syncing again.
+    sync_processor_->ClearChanges();
+    GetSyncableService(model_type)->StopSyncing(model_type);
+    sync_processor_wrapper_.reset(
+        new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
     GetSyncableService(model_type)
         ->MergeDataAndStartSyncing(
-            model_type, sync_data, std::move(sync_processor_wrapper_),
+            model_type, syncer::SyncDataList(),
+            std::move(sync_processor_wrapper_),
             base::MakeUnique<syncer::SyncErrorFactoryMock>());
-  }
-  GetExisting("bad")->set_status_code(ValueStore::OK);
 
-  {
-    base::DictionaryValue dict;
-    dict.Set("foo", fooValue.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
-  }
-  {
-    base::DictionaryValue dict;
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
-  }
+    // Local settings will have been pushed to sync, since it's empty (in this
+    // test; presumably it wouldn't be live, since we've been getting changes).
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
+              sync_processor_->GetOnlyChange("good", "foo")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
+              sync_processor_->GetOnlyChange("good", "bar")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
+              sync_processor_->GetOnlyChange("bad", "bar")->change_type());
+    EXPECT_EQ(3u, sync_processor_->changes().size());
 
-  // Changes made to good should be sent to sync, changes from bad shouldn't.
-  sync_processor_->ClearChanges();
-  good->Set(DEFAULTS, "bar", barValue);
-  bad->Set(DEFAULTS, "bar", barValue);
+    // Live local changes now get pushed, too.
+    sync_processor_->ClearChanges();
+    good->Set(DEFAULTS, "bar", barValue);
+    bad->Set(DEFAULTS, "bar", barValue);
 
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
-            sync_processor_->GetOnlyChange("good", "bar")->change_type());
-  EXPECT_EQ(1u, sync_processor_->changes().size());
+    EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
+              sync_processor_->GetOnlyChange("good", "bar")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
+              sync_processor_->GetOnlyChange("bad", "bar")->change_type());
+    EXPECT_EQ(2u, sync_processor_->changes().size());
 
-  {
-    base::DictionaryValue dict;
-    dict.Set("foo", fooValue.CreateDeepCopy());
-    dict.Set("bar", barValue.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
-  }
-  {
-    base::DictionaryValue dict;
-    dict.Set("bar", barValue.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
-  }
+    // And ProcessSyncChanges work, too.
+    {
+      syncer::SyncChangeList change_list;
+      change_list.push_back(settings_sync_util::CreateUpdate(
+          "good", "bar", fooValue, model_type));
+      change_list.push_back(
+          settings_sync_util::CreateUpdate("bad", "bar", fooValue, model_type));
+      GetSyncableService(model_type)
+          ->ProcessSyncChanges(FROM_HERE, change_list);
+    }
 
-  // Changes received from sync should go to good but not bad (even when it's
-  // not failing).
-  {
-    syncer::SyncChangeList change_list;
-    change_list.push_back(settings_sync_util::CreateUpdate(
-          "good", "foo", barValue, model_type));
-    // (Sending UPDATE here even though it's adding, since that's what the state
-    // of sync is.  In any case, it won't work.)
-    change_list.push_back(settings_sync_util::CreateUpdate(
-          "bad", "foo", barValue, model_type));
-    GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
-  }
-
-  {
-    base::DictionaryValue dict;
-    dict.Set("foo", barValue.CreateDeepCopy());
-    dict.Set("bar", barValue.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
-  }
-  {
-    base::DictionaryValue dict;
-    dict.Set("bar", barValue.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
-  }
-
-  // Changes made to bad still shouldn't go to sync, even though it didn't fail
-  // last time.
-  sync_processor_->ClearChanges();
-  good->Set(DEFAULTS, "bar", fooValue);
-  bad->Set(DEFAULTS, "bar", fooValue);
-
-  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
-            sync_processor_->GetOnlyChange("good", "bar")->change_type());
-  EXPECT_EQ(1u, sync_processor_->changes().size());
-
-  {
-    base::DictionaryValue dict;
-    dict.Set("foo", barValue.CreateDeepCopy());
-    dict.Set("bar", fooValue.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
-  }
-  {
-    base::DictionaryValue dict;
-    dict.Set("bar", fooValue.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
-  }
-
-  // Failing ProcessSyncChanges shouldn't go to the storage.
-  GetExisting("bad")->set_status_code(ValueStore::CORRUPTION);
-  {
-    syncer::SyncChangeList change_list;
-    change_list.push_back(settings_sync_util::CreateUpdate(
-          "good", "foo", fooValue, model_type));
-    // (Ditto.)
-    change_list.push_back(settings_sync_util::CreateUpdate(
-          "bad", "foo", fooValue, model_type));
-    GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
-  }
-  GetExisting("bad")->set_status_code(ValueStore::OK);
-
-  {
-    base::DictionaryValue dict;
-    dict.Set("foo", fooValue.CreateDeepCopy());
-    dict.Set("bar", fooValue.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
-  }
-  {
-    base::DictionaryValue dict;
-    dict.Set("bar", fooValue.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
-  }
-
-  // Restarting sync should make bad start syncing again.
-  sync_processor_->ClearChanges();
-  GetSyncableService(model_type)->StopSyncing(model_type);
-  sync_processor_wrapper_.reset(
-      new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
-  GetSyncableService(model_type)
-      ->MergeDataAndStartSyncing(
-          model_type, syncer::SyncDataList(),
-          std::move(sync_processor_wrapper_),
-          base::MakeUnique<syncer::SyncErrorFactoryMock>());
-
-  // Local settings will have been pushed to sync, since it's empty (in this
-  // test; presumably it wouldn't be live, since we've been getting changes).
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
-            sync_processor_->GetOnlyChange("good", "foo")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
-            sync_processor_->GetOnlyChange("good", "bar")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
-            sync_processor_->GetOnlyChange("bad", "bar")->change_type());
-  EXPECT_EQ(3u, sync_processor_->changes().size());
-
-  // Live local changes now get pushed, too.
-  sync_processor_->ClearChanges();
-  good->Set(DEFAULTS, "bar", barValue);
-  bad->Set(DEFAULTS, "bar", barValue);
-
-  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
-            sync_processor_->GetOnlyChange("good", "bar")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
-            sync_processor_->GetOnlyChange("bad", "bar")->change_type());
-  EXPECT_EQ(2u, sync_processor_->changes().size());
-
-  // And ProcessSyncChanges work, too.
-  {
-    syncer::SyncChangeList change_list;
-    change_list.push_back(settings_sync_util::CreateUpdate(
-          "good", "bar", fooValue, model_type));
-    change_list.push_back(settings_sync_util::CreateUpdate(
-          "bad", "bar", fooValue, model_type));
-    GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
-  }
-
-  {
-    base::DictionaryValue dict;
-    dict.Set("foo", fooValue.CreateDeepCopy());
-    dict.Set("bar", fooValue.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
-  }
-  {
-    base::DictionaryValue dict;
-    dict.Set("bar", fooValue.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
-  }
+    {
+      base::DictionaryValue dict;
+      dict.Set("foo", fooValue.CreateDeepCopy());
+      dict.Set("bar", fooValue.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
+    }
+    {
+      base::DictionaryValue dict;
+      dict.Set("bar", fooValue.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
+    }
+  });
 }
 
 TEST_F(ExtensionSettingsSyncTest, FailingProcessChangesDisablesSync) {
   // The test above tests a failing ProcessSyncChanges too, but here test with
   // an initially passing MergeDataAndStartSyncing.
   syncer::ModelType model_type = syncer::APP_SETTINGS;
   Manifest::Type type = Manifest::TYPE_LEGACY_PACKAGED_APP;
 
   base::Value fooValue("fooValue");
   base::Value barValue("barValue");
 
   ValueStore* good = AddExtensionAndGetStorage("good", type);
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
 
-  // Unlike before, initially succeeding MergeDataAndStartSyncing.
-  {
-    syncer::SyncDataList sync_data;
-    sync_data.push_back(settings_sync_util::CreateData(
-          "good", "foo", fooValue, model_type));
-    sync_data.push_back(settings_sync_util::CreateData(
-          "bad", "foo", fooValue, model_type));
-    GetSyncableService(model_type)
-        ->MergeDataAndStartSyncing(
-            model_type, sync_data, std::move(sync_processor_wrapper_),
-            base::MakeUnique<syncer::SyncErrorFactoryMock>());
-  }
+  PostOnBackendSequenceAndWait(FROM_HERE, [&, this]() {
+    // Unlike before, initially succeeding MergeDataAndStartSyncing.
+    {
+      syncer::SyncDataList sync_data;
+      sync_data.push_back(
+          settings_sync_util::CreateData("good", "foo", fooValue, model_type));
+      sync_data.push_back(
+          settings_sync_util::CreateData("bad", "foo", fooValue, model_type));
+      GetSyncableService(model_type)
+          ->MergeDataAndStartSyncing(
+              model_type, sync_data, std::move(sync_processor_wrapper_),
+              base::MakeUnique<syncer::SyncErrorFactoryMock>());
+    }
 
-  EXPECT_EQ(0u, sync_processor_->changes().size());
+    EXPECT_EQ(0u, sync_processor_->changes().size());
 
-  {
-    base::DictionaryValue dict;
-    dict.Set("foo", fooValue.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
-  }
-  {
-    base::DictionaryValue dict;
-    dict.Set("foo", fooValue.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
-  }
+    {
+      base::DictionaryValue dict;
+      dict.Set("foo", fooValue.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
+    }
+    {
+      base::DictionaryValue dict;
+      dict.Set("foo", fooValue.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
+    }
 
-  // Now fail ProcessSyncChanges for bad.
-  GetExisting("bad")->set_status_code(ValueStore::CORRUPTION);
-  {
-    syncer::SyncChangeList change_list;
-    change_list.push_back(settings_sync_util::CreateAdd(
-          "good", "bar", barValue, model_type));
-    change_list.push_back(settings_sync_util::CreateAdd(
-          "bad", "bar", barValue, model_type));
-    GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
-  }
-  GetExisting("bad")->set_status_code(ValueStore::OK);
+    // Now fail ProcessSyncChanges for bad.
+    GetExisting("bad")->set_status_code(ValueStore::CORRUPTION);
+    {
+      syncer::SyncChangeList change_list;
+      change_list.push_back(
+          settings_sync_util::CreateAdd("good", "bar", barValue, model_type));
+      change_list.push_back(
+          settings_sync_util::CreateAdd("bad", "bar", barValue, model_type));
+      GetSyncableService(model_type)
+          ->ProcessSyncChanges(FROM_HERE, change_list);
+    }
+    GetExisting("bad")->set_status_code(ValueStore::OK);
 
-  {
-    base::DictionaryValue dict;
-    dict.Set("foo", fooValue.CreateDeepCopy());
-    dict.Set("bar", barValue.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
-  }
-  {
-    base::DictionaryValue dict;
-    dict.Set("foo", fooValue.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
-  }
+    {
+      base::DictionaryValue dict;
+      dict.Set("foo", fooValue.CreateDeepCopy());
+      dict.Set("bar", barValue.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
+    }
+    {
+      base::DictionaryValue dict;
+      dict.Set("foo", fooValue.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
+    }
 
-  // No more changes sent to sync for bad.
-  sync_processor_->ClearChanges();
-  good->Set(DEFAULTS, "foo", barValue);
-  bad->Set(DEFAULTS, "foo", barValue);
+    // No more changes sent to sync for bad.
+    sync_processor_->ClearChanges();
+    good->Set(DEFAULTS, "foo", barValue);
+    bad->Set(DEFAULTS, "foo", barValue);
 
-  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
-            sync_processor_->GetOnlyChange("good", "foo")->change_type());
-  EXPECT_EQ(1u, sync_processor_->changes().size());
+    EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
+              sync_processor_->GetOnlyChange("good", "foo")->change_type());
+    EXPECT_EQ(1u, sync_processor_->changes().size());
 
-  // No more changes received from sync should go to bad.
-  {
-    syncer::SyncChangeList change_list;
-    change_list.push_back(settings_sync_util::CreateAdd(
-          "good", "foo", fooValue, model_type));
-    change_list.push_back(settings_sync_util::CreateAdd(
-          "bad", "foo", fooValue, model_type));
-    GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
-  }
+    // No more changes received from sync should go to bad.
+    {
+      syncer::SyncChangeList change_list;
+      change_list.push_back(
+          settings_sync_util::CreateAdd("good", "foo", fooValue, model_type));
+      change_list.push_back(
+          settings_sync_util::CreateAdd("bad", "foo", fooValue, model_type));
+      GetSyncableService(model_type)
+          ->ProcessSyncChanges(FROM_HERE, change_list);
+    }
 
-  {
-    base::DictionaryValue dict;
-    dict.Set("foo", fooValue.CreateDeepCopy());
-    dict.Set("bar", barValue.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
-  }
-  {
-    base::DictionaryValue dict;
-    dict.Set("foo", barValue.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
-  }
+    {
+      base::DictionaryValue dict;
+      dict.Set("foo", fooValue.CreateDeepCopy());
+      dict.Set("bar", barValue.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
+    }
+    {
+      base::DictionaryValue dict;
+      dict.Set("foo", barValue.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
+    }
+  });
 }
 
 TEST_F(ExtensionSettingsSyncTest, FailingGetAllSyncDataDoesntStopSync) {
   syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Manifest::Type type = Manifest::TYPE_EXTENSION;
 
   base::Value fooValue("fooValue");
   base::Value barValue("barValue");
 
   ValueStore* good = AddExtensionAndGetStorage("good", type);
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
 
-  good->Set(DEFAULTS, "foo", fooValue);
-  bad->Set(DEFAULTS, "foo", fooValue);
+  PostOnBackendSequenceAndWait(FROM_HERE, [&, this]() {
+    good->Set(DEFAULTS, "foo", fooValue);
+    bad->Set(DEFAULTS, "foo", fooValue);
 
-  // Even though bad will fail to get all sync data, sync data should still
-  // include that from good.
-  GetExisting("bad")->set_status_code(ValueStore::CORRUPTION);
-  {
-    syncer::SyncDataList all_sync_data =
-        GetSyncableService(model_type)->GetAllSyncData(model_type);
-    EXPECT_EQ(1u, all_sync_data.size());
-    EXPECT_EQ("good/foo", syncer::SyncDataLocal(all_sync_data[0]).GetTag());
-  }
-  GetExisting("bad")->set_status_code(ValueStore::OK);
+    // Even though bad will fail to get all sync data, sync data should still
+    // include that from good.
+    GetExisting("bad")->set_status_code(ValueStore::CORRUPTION);
+    {
+      syncer::SyncDataList all_sync_data =
+          GetSyncableService(model_type)->GetAllSyncData(model_type);
+      EXPECT_EQ(1u, all_sync_data.size());
+      EXPECT_EQ("good/foo", syncer::SyncDataLocal(all_sync_data[0]).GetTag());
+    }
+    GetExisting("bad")->set_status_code(ValueStore::OK);
 
-  // Sync shouldn't be disabled for good (nor bad -- but this is unimportant).
-  GetSyncableService(model_type)
-      ->MergeDataAndStartSyncing(
-          model_type, syncer::SyncDataList(),
-          std::move(sync_processor_wrapper_),
-          base::MakeUnique<syncer::SyncErrorFactoryMock>());
+    // Sync shouldn't be disabled for good (nor bad -- but this is unimportant).
+    GetSyncableService(model_type)
+        ->MergeDataAndStartSyncing(
+            model_type, syncer::SyncDataList(),
+            std::move(sync_processor_wrapper_),
+            base::MakeUnique<syncer::SyncErrorFactoryMock>());
 
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
-            sync_processor_->GetOnlyChange("good", "foo")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
-            sync_processor_->GetOnlyChange("bad", "foo")->change_type());
-  EXPECT_EQ(2u, sync_processor_->changes().size());
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
+              sync_processor_->GetOnlyChange("good", "foo")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
+              sync_processor_->GetOnlyChange("bad", "foo")->change_type());
+    EXPECT_EQ(2u, sync_processor_->changes().size());
 
-  sync_processor_->ClearChanges();
-  good->Set(DEFAULTS, "bar", barValue);
-  bad->Set(DEFAULTS, "bar", barValue);
+    sync_processor_->ClearChanges();
+    good->Set(DEFAULTS, "bar", barValue);
+    bad->Set(DEFAULTS, "bar", barValue);
 
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
-            sync_processor_->GetOnlyChange("good", "bar")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
-            sync_processor_->GetOnlyChange("bad", "bar")->change_type());
-  EXPECT_EQ(2u, sync_processor_->changes().size());
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
+              sync_processor_->GetOnlyChange("good", "bar")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
+              sync_processor_->GetOnlyChange("bad", "bar")->change_type());
+    EXPECT_EQ(2u, sync_processor_->changes().size());
+  });
 }
 
 TEST_F(ExtensionSettingsSyncTest, FailureToReadChangesToPushDisablesSync) {
   syncer::ModelType model_type = syncer::APP_SETTINGS;
   Manifest::Type type = Manifest::TYPE_LEGACY_PACKAGED_APP;
 
   base::Value fooValue("fooValue");
   base::Value barValue("barValue");
 
   ValueStore* good = AddExtensionAndGetStorage("good", type);
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
 
-  good->Set(DEFAULTS, "foo", fooValue);
-  bad->Set(DEFAULTS, "foo", fooValue);
+  PostOnBackendSequenceAndWait(FROM_HERE, [&, this]() {
+    good->Set(DEFAULTS, "foo", fooValue);
+    bad->Set(DEFAULTS, "foo", fooValue);
 
-  // good will successfully push foo:fooValue to sync, but bad will fail to
-  // get them so won't.
-  GetExisting("bad")->set_status_code(ValueStore::CORRUPTION);
-  GetSyncableService(model_type)
-      ->MergeDataAndStartSyncing(
-          model_type, syncer::SyncDataList(),
-          std::move(sync_processor_wrapper_),
-          base::MakeUnique<syncer::SyncErrorFactoryMock>());
-  GetExisting("bad")->set_status_code(ValueStore::OK);
+    // good will successfully push foo:fooValue to sync, but bad will fail to
+    // get them so won't.
+    GetExisting("bad")->set_status_code(ValueStore::CORRUPTION);
+    GetSyncableService(model_type)
+        ->MergeDataAndStartSyncing(
+            model_type, syncer::SyncDataList(),
+            std::move(sync_processor_wrapper_),
+            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+    GetExisting("bad")->set_status_code(ValueStore::OK);
 
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
-            sync_processor_->GetOnlyChange("good", "foo")->change_type());
-  EXPECT_EQ(1u, sync_processor_->changes().size());
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
+              sync_processor_->GetOnlyChange("good", "foo")->change_type());
+    EXPECT_EQ(1u, sync_processor_->changes().size());
 
-  // bad should now be disabled for sync.
-  sync_processor_->ClearChanges();
-  good->Set(DEFAULTS, "bar", barValue);
-  bad->Set(DEFAULTS, "bar", barValue);
+    // bad should now be disabled for sync.
+    sync_processor_->ClearChanges();
+    good->Set(DEFAULTS, "bar", barValue);
+    bad->Set(DEFAULTS, "bar", barValue);
 
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
-            sync_processor_->GetOnlyChange("good", "bar")->change_type());
-  EXPECT_EQ(1u, sync_processor_->changes().size());
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
+              sync_processor_->GetOnlyChange("good", "bar")->change_type());
+    EXPECT_EQ(1u, sync_processor_->changes().size());
 
-  {
-    syncer::SyncChangeList change_list;
-    change_list.push_back(settings_sync_util::CreateUpdate(
+    {
+      syncer::SyncChangeList change_list;
+      change_list.push_back(settings_sync_util::CreateUpdate(
           "good", "foo", barValue, model_type));
-    // (Sending ADD here even though it's updating, since that's what the state
-    // of sync is.  In any case, it won't work.)
-    change_list.push_back(settings_sync_util::CreateAdd(
-          "bad", "foo", barValue, model_type));
-    GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
-  }
+      // (Sending ADD here even though it's updating, since that's what the
+      // state of sync is.  In any case, it won't work.)
+      change_list.push_back(
+          settings_sync_util::CreateAdd("bad", "foo", barValue, model_type));
+      GetSyncableService(model_type)
+          ->ProcessSyncChanges(FROM_HERE, change_list);
+    }
 
-  {
-    base::DictionaryValue dict;
-    dict.Set("foo", barValue.CreateDeepCopy());
-    dict.Set("bar", barValue.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
-  }
-  {
-    base::DictionaryValue dict;
-    dict.Set("foo", fooValue.CreateDeepCopy());
-    dict.Set("bar", barValue.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
-  }
+    {
+      base::DictionaryValue dict;
+      dict.Set("foo", barValue.CreateDeepCopy());
+      dict.Set("bar", barValue.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
+    }
+    {
+      base::DictionaryValue dict;
+      dict.Set("foo", fooValue.CreateDeepCopy());
+      dict.Set("bar", barValue.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
+    }
 
-  // Re-enabling sync without failing should cause the local changes from bad
-  // to be pushed to sync successfully, as should future changes to bad.
-  sync_processor_->ClearChanges();
-  GetSyncableService(model_type)->StopSyncing(model_type);
-  sync_processor_wrapper_.reset(
-      new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
-  GetSyncableService(model_type)
-      ->MergeDataAndStartSyncing(
-          model_type, syncer::SyncDataList(),
-          std::move(sync_processor_wrapper_),
-          base::MakeUnique<syncer::SyncErrorFactoryMock>());
+    // Re-enabling sync without failing should cause the local changes from bad
+    // to be pushed to sync successfully, as should future changes to bad.
+    sync_processor_->ClearChanges();
+    GetSyncableService(model_type)->StopSyncing(model_type);
+    sync_processor_wrapper_.reset(
+        new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
+    GetSyncableService(model_type)
+        ->MergeDataAndStartSyncing(
+            model_type, syncer::SyncDataList(),
+            std::move(sync_processor_wrapper_),
+            base::MakeUnique<syncer::SyncErrorFactoryMock>());
 
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
-            sync_processor_->GetOnlyChange("good", "foo")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
-            sync_processor_->GetOnlyChange("good", "bar")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
-            sync_processor_->GetOnlyChange("bad", "foo")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
-            sync_processor_->GetOnlyChange("bad", "bar")->change_type());
-  EXPECT_EQ(4u, sync_processor_->changes().size());
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
+              sync_processor_->GetOnlyChange("good", "foo")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
+              sync_processor_->GetOnlyChange("good", "bar")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
+              sync_processor_->GetOnlyChange("bad", "foo")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
+              sync_processor_->GetOnlyChange("bad", "bar")->change_type());
+    EXPECT_EQ(4u, sync_processor_->changes().size());
 
-  sync_processor_->ClearChanges();
-  good->Set(DEFAULTS, "bar", fooValue);
-  bad->Set(DEFAULTS, "bar", fooValue);
+    sync_processor_->ClearChanges();
+    good->Set(DEFAULTS, "bar", fooValue);
+    bad->Set(DEFAULTS, "bar", fooValue);
 
-  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
-            sync_processor_->GetOnlyChange("good", "bar")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
-            sync_processor_->GetOnlyChange("good", "bar")->change_type());
-  EXPECT_EQ(2u, sync_processor_->changes().size());
+    EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
+              sync_processor_->GetOnlyChange("good", "bar")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
+              sync_processor_->GetOnlyChange("good", "bar")->change_type());
+    EXPECT_EQ(2u, sync_processor_->changes().size());
+  });
 }
 
 TEST_F(ExtensionSettingsSyncTest, FailureToPushLocalStateDisablesSync) {
   syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Manifest::Type type = Manifest::TYPE_EXTENSION;
 
   base::Value fooValue("fooValue");
   base::Value barValue("barValue");
 
   ValueStore* good = AddExtensionAndGetStorage("good", type);
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
 
-  // Only set bad; setting good will cause it to fail below.
-  bad->Set(DEFAULTS, "foo", fooValue);
+  PostOnBackendSequenceAndWait(FROM_HERE, [&, this]() {
+    // Only set bad; setting good will cause it to fail below.
+    bad->Set(DEFAULTS, "foo", fooValue);
 
-  sync_processor_->set_fail_all_requests(true);
-  GetSyncableService(model_type)
-      ->MergeDataAndStartSyncing(
-          model_type, syncer::SyncDataList(),
-          std::move(sync_processor_wrapper_),
-          base::MakeUnique<syncer::SyncErrorFactoryMock>());
-  sync_processor_->set_fail_all_requests(false);
+    sync_processor_->set_fail_all_requests(true);
+    GetSyncableService(model_type)
+        ->MergeDataAndStartSyncing(
+            model_type, syncer::SyncDataList(),
+            std::move(sync_processor_wrapper_),
+            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+    sync_processor_->set_fail_all_requests(false);
 
-  // Changes from good will be send to sync, changes from bad won't.
-  sync_processor_->ClearChanges();
-  good->Set(DEFAULTS, "foo", barValue);
-  bad->Set(DEFAULTS, "foo", barValue);
+    // Changes from good will be send to sync, changes from bad won't.
+    sync_processor_->ClearChanges();
+    good->Set(DEFAULTS, "foo", barValue);
+    bad->Set(DEFAULTS, "foo", barValue);
 
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
-            sync_processor_->GetOnlyChange("good", "foo")->change_type());
-  EXPECT_EQ(1u, sync_processor_->changes().size());
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
+              sync_processor_->GetOnlyChange("good", "foo")->change_type());
+    EXPECT_EQ(1u, sync_processor_->changes().size());
 
-  // Changes from sync will be sent to good, not to bad.
-  {
-    syncer::SyncChangeList change_list;
-    change_list.push_back(settings_sync_util::CreateAdd(
-          "good", "bar", barValue, model_type));
-    change_list.push_back(settings_sync_util::CreateAdd(
-          "bad", "bar", barValue, model_type));
-    GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
-  }
+    // Changes from sync will be sent to good, not to bad.
+    {
+      syncer::SyncChangeList change_list;
+      change_list.push_back(
+          settings_sync_util::CreateAdd("good", "bar", barValue, model_type));
+      change_list.push_back(
+          settings_sync_util::CreateAdd("bad", "bar", barValue, model_type));
+      GetSyncableService(model_type)
+          ->ProcessSyncChanges(FROM_HERE, change_list);
+    }
 
-  {
-    base::DictionaryValue dict;
-    dict.Set("foo", barValue.CreateDeepCopy());
-    dict.Set("bar", barValue.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
-  }
-  {
-    base::DictionaryValue dict;
-    dict.Set("foo", barValue.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
-  }
+    {
+      base::DictionaryValue dict;
+      dict.Set("foo", barValue.CreateDeepCopy());
+      dict.Set("bar", barValue.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
+    }
+    {
+      base::DictionaryValue dict;
+      dict.Set("foo", barValue.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
+    }
 
-  // Restarting sync makes everything work again.
-  sync_processor_->ClearChanges();
-  GetSyncableService(model_type)->StopSyncing(model_type);
-  sync_processor_wrapper_.reset(
-      new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
-  GetSyncableService(model_type)
-      ->MergeDataAndStartSyncing(
-          model_type, syncer::SyncDataList(),
-          std::move(sync_processor_wrapper_),
-          base::MakeUnique<syncer::SyncErrorFactoryMock>());
+    // Restarting sync makes everything work again.
+    sync_processor_->ClearChanges();
+    GetSyncableService(model_type)->StopSyncing(model_type);
+    sync_processor_wrapper_.reset(
+        new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
+    GetSyncableService(model_type)
+        ->MergeDataAndStartSyncing(
+            model_type, syncer::SyncDataList(),
+            std::move(sync_processor_wrapper_),
+            base::MakeUnique<syncer::SyncErrorFactoryMock>());
 
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
-            sync_processor_->GetOnlyChange("good", "foo")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
-            sync_processor_->GetOnlyChange("good", "bar")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
-            sync_processor_->GetOnlyChange("bad", "foo")->change_type());
-  EXPECT_EQ(3u, sync_processor_->changes().size());
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
+              sync_processor_->GetOnlyChange("good", "foo")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
+              sync_processor_->GetOnlyChange("good", "bar")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
+              sync_processor_->GetOnlyChange("bad", "foo")->change_type());
+    EXPECT_EQ(3u, sync_processor_->changes().size());
 
-  sync_processor_->ClearChanges();
-  good->Set(DEFAULTS, "foo", fooValue);
-  bad->Set(DEFAULTS, "foo", fooValue);
+    sync_processor_->ClearChanges();
+    good->Set(DEFAULTS, "foo", fooValue);
+    bad->Set(DEFAULTS, "foo", fooValue);
 
-  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
-            sync_processor_->GetOnlyChange("good", "foo")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
-            sync_processor_->GetOnlyChange("good", "foo")->change_type());
-  EXPECT_EQ(2u, sync_processor_->changes().size());
+    EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
+              sync_processor_->GetOnlyChange("good", "foo")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
+              sync_processor_->GetOnlyChange("good", "foo")->change_type());
+    EXPECT_EQ(2u, sync_processor_->changes().size());
+  });
 }
 
 TEST_F(ExtensionSettingsSyncTest, FailureToPushLocalChangeDisablesSync) {
   syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Manifest::Type type = Manifest::TYPE_EXTENSION;
 
   base::Value fooValue("fooValue");
   base::Value barValue("barValue");
 
   ValueStore* good = AddExtensionAndGetStorage("good", type);
   ValueStore* bad = AddExtensionAndGetStorage("bad", type);
 
-  GetSyncableService(model_type)
-      ->MergeDataAndStartSyncing(
-          model_type, syncer::SyncDataList(),
-          std::move(sync_processor_wrapper_),
-          base::MakeUnique<syncer::SyncErrorFactoryMock>());
+  PostOnBackendSequenceAndWait(FROM_HERE, [&, this]() {
+    GetSyncableService(model_type)
+        ->MergeDataAndStartSyncing(
+            model_type, syncer::SyncDataList(),
+            std::move(sync_processor_wrapper_),
+            base::MakeUnique<syncer::SyncErrorFactoryMock>());
 
-  // bad will fail to send changes.
-  good->Set(DEFAULTS, "foo", fooValue);
-  sync_processor_->set_fail_all_requests(true);
-  bad->Set(DEFAULTS, "foo", fooValue);
-  sync_processor_->set_fail_all_requests(false);
+    // bad will fail to send changes.
+    good->Set(DEFAULTS, "foo", fooValue);
+    sync_processor_->set_fail_all_requests(true);
+    bad->Set(DEFAULTS, "foo", fooValue);
+    sync_processor_->set_fail_all_requests(false);
 
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
-            sync_processor_->GetOnlyChange("good", "foo")->change_type());
-  EXPECT_EQ(1u, sync_processor_->changes().size());
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
+              sync_processor_->GetOnlyChange("good", "foo")->change_type());
+    EXPECT_EQ(1u, sync_processor_->changes().size());
 
-  // No further changes should be sent from bad.
-  sync_processor_->ClearChanges();
-  good->Set(DEFAULTS, "foo", barValue);
-  bad->Set(DEFAULTS, "foo", barValue);
+    // No further changes should be sent from bad.
+    sync_processor_->ClearChanges();
+    good->Set(DEFAULTS, "foo", barValue);
+    bad->Set(DEFAULTS, "foo", barValue);
 
-  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
-            sync_processor_->GetOnlyChange("good", "foo")->change_type());
-  EXPECT_EQ(1u, sync_processor_->changes().size());
+    EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
+              sync_processor_->GetOnlyChange("good", "foo")->change_type());
+    EXPECT_EQ(1u, sync_processor_->changes().size());
 
-  // Changes from sync will be sent to good, not to bad.
-  {
-    syncer::SyncChangeList change_list;
-    change_list.push_back(settings_sync_util::CreateAdd(
-          "good", "bar", barValue, model_type));
-    change_list.push_back(settings_sync_util::CreateAdd(
-          "bad", "bar", barValue, model_type));
-    GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
-  }
+    // Changes from sync will be sent to good, not to bad.
+    {
+      syncer::SyncChangeList change_list;
+      change_list.push_back(
+          settings_sync_util::CreateAdd("good", "bar", barValue, model_type));
+      change_list.push_back(
+          settings_sync_util::CreateAdd("bad", "bar", barValue, model_type));
+      GetSyncableService(model_type)
+          ->ProcessSyncChanges(FROM_HERE, change_list);
+    }
 
-  {
-    base::DictionaryValue dict;
-    dict.Set("foo", barValue.CreateDeepCopy());
-    dict.Set("bar", barValue.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
-  }
-  {
-    base::DictionaryValue dict;
-    dict.Set("foo", barValue.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
-  }
+    {
+      base::DictionaryValue dict;
+      dict.Set("foo", barValue.CreateDeepCopy());
+      dict.Set("bar", barValue.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, good->Get());
+    }
+    {
+      base::DictionaryValue dict;
+      dict.Set("foo", barValue.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, dict, bad->Get());
+    }
 
-  // Restarting sync makes everything work again.
-  sync_processor_->ClearChanges();
-  GetSyncableService(model_type)->StopSyncing(model_type);
-  sync_processor_wrapper_.reset(
-      new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
-  GetSyncableService(model_type)
-      ->MergeDataAndStartSyncing(
-          model_type, syncer::SyncDataList(),
-          std::move(sync_processor_wrapper_),
-          base::MakeUnique<syncer::SyncErrorFactoryMock>());
+    // Restarting sync makes everything work again.
+    sync_processor_->ClearChanges();
+    GetSyncableService(model_type)->StopSyncing(model_type);
+    sync_processor_wrapper_.reset(
+        new syncer::SyncChangeProcessorWrapperForTest(sync_processor_.get()));
+    GetSyncableService(model_type)
+        ->MergeDataAndStartSyncing(
+            model_type, syncer::SyncDataList(),
+            std::move(sync_processor_wrapper_),
+            base::MakeUnique<syncer::SyncErrorFactoryMock>());
 
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
-            sync_processor_->GetOnlyChange("good", "foo")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
-            sync_processor_->GetOnlyChange("good", "bar")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
-            sync_processor_->GetOnlyChange("bad", "foo")->change_type());
-  EXPECT_EQ(3u, sync_processor_->changes().size());
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
+              sync_processor_->GetOnlyChange("good", "foo")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
+              sync_processor_->GetOnlyChange("good", "bar")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_ADD,
+              sync_processor_->GetOnlyChange("bad", "foo")->change_type());
+    EXPECT_EQ(3u, sync_processor_->changes().size());
 
-  sync_processor_->ClearChanges();
-  good->Set(DEFAULTS, "foo", fooValue);
-  bad->Set(DEFAULTS, "foo", fooValue);
+    sync_processor_->ClearChanges();
+    good->Set(DEFAULTS, "foo", fooValue);
+    bad->Set(DEFAULTS, "foo", fooValue);
 
-  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
-            sync_processor_->GetOnlyChange("good", "foo")->change_type());
-  EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
-            sync_processor_->GetOnlyChange("good", "foo")->change_type());
-  EXPECT_EQ(2u, sync_processor_->changes().size());
+    EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
+              sync_processor_->GetOnlyChange("good", "foo")->change_type());
+    EXPECT_EQ(syncer::SyncChange::ACTION_UPDATE,
+              sync_processor_->GetOnlyChange("good", "foo")->change_type());
+    EXPECT_EQ(2u, sync_processor_->changes().size());
+  });
 }
 
 TEST_F(ExtensionSettingsSyncTest,
        LargeOutgoingChangeRejectedButIncomingAccepted) {
   syncer::ModelType model_type = syncer::APP_SETTINGS;
   Manifest::Type type = Manifest::TYPE_LEGACY_PACKAGED_APP;
 
   // This value should be larger than the limit in sync_storage_backend.cc.
   std::string string_10k;
   for (size_t i = 0; i < 10000; ++i) {
     string_10k.append("a");
   }
   base::Value large_value(string_10k);
 
-  GetSyncableService(model_type)
-      ->MergeDataAndStartSyncing(
-          model_type, syncer::SyncDataList(),
-          std::move(sync_processor_wrapper_),
-          base::MakeUnique<syncer::SyncErrorFactoryMock>());
+  PostOnBackendSequenceAndWait(FROM_HERE, [&, this]() {
+    GetSyncableService(model_type)
+        ->MergeDataAndStartSyncing(
+            model_type, syncer::SyncDataList(),
+            std::move(sync_processor_wrapper_),
+            base::MakeUnique<syncer::SyncErrorFactoryMock>());
+  });
 
   // Large local change rejected and doesn't get sent out.
   ValueStore* storage1 = AddExtensionAndGetStorage("s1", type);
-  EXPECT_FALSE(
-      storage1->Set(DEFAULTS, "large_value", large_value)->status().ok());
-  EXPECT_EQ(0u, sync_processor_->changes().size());
+
+  PostOnBackendSequenceAndWait(FROM_HERE, [&, this]() {
+    EXPECT_FALSE(
+        storage1->Set(DEFAULTS, "large_value", large_value)->status().ok());
+    EXPECT_EQ(0u, sync_processor_->changes().size());
+  });
 
   // Large incoming change should still get accepted.
   ValueStore* storage2 = AddExtensionAndGetStorage("s2", type);
-  {
-    syncer::SyncChangeList change_list;
-    change_list.push_back(settings_sync_util::CreateAdd(
+
+  PostOnBackendSequenceAndWait(FROM_HERE, [&, this]() {
+    {
+      syncer::SyncChangeList change_list;
+      change_list.push_back(settings_sync_util::CreateAdd(
           "s1", "large_value", large_value, model_type));
-    change_list.push_back(settings_sync_util::CreateAdd(
+      change_list.push_back(settings_sync_util::CreateAdd(
           "s2", "large_value", large_value, model_type));
-    GetSyncableService(model_type)->ProcessSyncChanges(FROM_HERE, change_list);
-  }
-  {
-    base::DictionaryValue expected;
-    expected.Set("large_value", large_value.CreateDeepCopy());
-    EXPECT_PRED_FORMAT2(SettingsEq, expected, storage1->Get());
-    EXPECT_PRED_FORMAT2(SettingsEq, expected, storage2->Get());
-  }
+      GetSyncableService(model_type)
+          ->ProcessSyncChanges(FROM_HERE, change_list);
+    }
+    {
+      base::DictionaryValue expected;
+      expected.Set("large_value", large_value.CreateDeepCopy());
+      EXPECT_PRED_FORMAT2(SettingsEq, expected, storage1->Get());
+      EXPECT_PRED_FORMAT2(SettingsEq, expected, storage2->Get());
+    }
 
-  GetSyncableService(model_type)->StopSyncing(model_type);
+    GetSyncableService(model_type)->StopSyncing(model_type);
+  });
 }
 
 TEST_F(ExtensionSettingsSyncTest, Dots) {
   syncer::ModelType model_type = syncer::EXTENSION_SETTINGS;
   Manifest::Type type = Manifest::TYPE_EXTENSION;
 
   ValueStore* storage = AddExtensionAndGetStorage("ext", type);
 
-  {
-    syncer::SyncDataList sync_data_list;
-    std::unique_ptr<base::Value> string_value(new base::Value("value"));
-    sync_data_list.push_back(settings_sync_util::CreateData(
-        "ext", "key.with.dot", *string_value, model_type));
+  PostOnBackendSequenceAndWait(FROM_HERE, [&, this]() {
+    {
+      syncer::SyncDataList sync_data_list;
+      std::unique_ptr<base::Value> string_value(new base::Value("value"));
+      sync_data_list.push_back(settings_sync_util::CreateData(
+          "ext", "key.with.dot", *string_value, model_type));
 
-    GetSyncableService(model_type)
-        ->MergeDataAndStartSyncing(
-            model_type, sync_data_list, std::move(sync_processor_wrapper_),
-            base::MakeUnique<syncer::SyncErrorFactoryMock>());
-  }
+      GetSyncableService(model_type)
+          ->MergeDataAndStartSyncing(
+              model_type, sync_data_list, std::move(sync_processor_wrapper_),
+              base::MakeUnique<syncer::SyncErrorFactoryMock>());
+    }
 
-  // Test dots in keys that come from sync.
-  {
-    ValueStore::ReadResult data = storage->Get();
-    ASSERT_TRUE(data->status().ok());
+    // Test dots in keys that come from sync.
+    {
+      ValueStore::ReadResult data = storage->Get();
+      ASSERT_TRUE(data->status().ok());
 
-    base::DictionaryValue expected_data;
-    expected_data.SetWithoutPathExpansion(
-        "key.with.dot", base::MakeUnique<base::Value>("value"));
-    EXPECT_TRUE(base::Value::Equals(&expected_data, &data->settings()));
-  }
+      base::DictionaryValue expected_data;
+      expected_data.SetWithoutPathExpansion(
+          "key.with.dot", base::MakeUnique<base::Value>("value"));
+      EXPECT_TRUE(base::Value::Equals(&expected_data, &data->settings()));
+    }
 
-  // Test dots in keys going to sync.
-  {
-    std::unique_ptr<base::Value> string_value(new base::Value("spot"));
-    storage->Set(DEFAULTS, "key.with.spot", *string_value);
+    // Test dots in keys going to sync.
+    {
+      std::unique_ptr<base::Value> string_value(new base::Value("spot"));
+      storage->Set(DEFAULTS, "key.with.spot", *string_value);
 
-    ASSERT_EQ(1u, sync_processor_->changes().size());
-    SettingSyncData* sync_data = sync_processor_->changes()[0].get();
-    EXPECT_EQ(syncer::SyncChange::ACTION_ADD, sync_data->change_type());
-    EXPECT_EQ("ext", sync_data->extension_id());
-    EXPECT_EQ("key.with.spot", sync_data->key());
-    EXPECT_TRUE(sync_data->value().Equals(string_value.get()));
-  }
+      ASSERT_EQ(1u, sync_processor_->changes().size());
+      SettingSyncData* sync_data = sync_processor_->changes()[0].get();
+      EXPECT_EQ(syncer::SyncChange::ACTION_ADD, sync_data->change_type());
+      EXPECT_EQ("ext", sync_data->extension_id());
+      EXPECT_EQ("key.with.spot", sync_data->key());
+      EXPECT_TRUE(sync_data->value().Equals(string_value.get()));
+    }
+  });
 }
 
 // In other (frontend) tests, we assume that the result of GetStorage
 // is a pointer to the a Storage owned by a Frontend object, but for
 // the unlimitedStorage case, this might not be true. So, write the
 // tests in a "callback" style.  We should really rewrite all tests to
 // be asynchronous in this way.
 
 namespace {
 
@@ skipping 38 matching lines @@
       util::AddExtensionWithIdAndPermissions(
           profile_.get(), id, Manifest::TYPE_EXTENSION, permissions);
 
   frontend_->RunWithStorage(extension,
                             settings_namespace::SYNC,
                             base::Bind(&UnlimitedSyncStorageTestCallback));
   frontend_->RunWithStorage(extension,
                             settings_namespace::LOCAL,
                             base::Bind(&UnlimitedLocalStorageTestCallback));
 
-  base::RunLoop().RunUntilIdle();
+  content::RunAllBlockingPoolTasksUntilIdle();
 }
 
 }  // namespace extensions