Migrate Extensions code to Task Scheduler API

chrome/browser/extensions/api/storage/syncable_settings_storage.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/extensions/api/storage/syncable_settings_storage.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/extensions/api/storage/settings_sync_processor.h"
 #include "chrome/browser/extensions/api/storage/settings_sync_util.h"
 #include "components/sync/model/sync_data.h"
 #include "components/sync/protocol/extension_setting_specifics.pb.h"
-#include "content/public/browser/browser_thread.h"
+#include "extensions/browser/api/storage/backend_task_runner.h"
 #include "extensions/browser/api/storage/settings_namespace.h"
 
-using content::BrowserThread;
-
 namespace extensions {
 
 SyncableSettingsStorage::SyncableSettingsStorage(
     const scoped_refptr<base::ObserverListThreadSafe<SettingsObserver>>&
         observers,
     const std::string& extension_id,
     ValueStore* delegate,
     syncer::ModelType sync_type,
     const syncer::SyncableService::StartSyncFlare& flare)
     : observers_(observers),
       extension_id_(extension_id),
       delegate_(delegate),
       sync_type_(sync_type),
       flare_(flare) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(IsOnBackendSequence());
 }
 
 SyncableSettingsStorage::~SyncableSettingsStorage() {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(IsOnBackendSequence());
 }
 
 size_t SyncableSettingsStorage::GetBytesInUse(const std::string& key) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(IsOnBackendSequence());
   return delegate_->GetBytesInUse(key);
 }
 
 size_t SyncableSettingsStorage::GetBytesInUse(
     const std::vector<std::string>& keys) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(IsOnBackendSequence());
   return delegate_->GetBytesInUse(keys);
 }
 
 size_t SyncableSettingsStorage::GetBytesInUse() {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(IsOnBackendSequence());
   return delegate_->GetBytesInUse();
 }
 
 template <class T>
 T SyncableSettingsStorage::HandleResult(T result) {
   if (result->status().restore_status != RESTORE_NONE) {
     // If we're syncing, stop - we don't want to push the deletion of any data.
     // At next startup, when we start up the sync service, we'll get back any
     // data which was stored intact on Sync.
     // TODO(devlin): Investigate if there's a way we can trigger
     // MergeDataAndStartSyncing() to immediately get back any data we can, and
     // continue syncing.
     StopSyncing();
   }
   return result;
 }
 
 ValueStore::ReadResult SyncableSettingsStorage::Get(
     const std::string& key) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(IsOnBackendSequence());
   return HandleResult(delegate_->Get(key));
 }
 
 ValueStore::ReadResult SyncableSettingsStorage::Get(
     const std::vector<std::string>& keys) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(IsOnBackendSequence());
   return HandleResult(delegate_->Get(keys));
 }
 
 ValueStore::ReadResult SyncableSettingsStorage::Get() {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(IsOnBackendSequence());
   return HandleResult(delegate_->Get());
 }
 
 ValueStore::WriteResult SyncableSettingsStorage::Set(
     WriteOptions options, const std::string& key, const base::Value& value) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(IsOnBackendSequence());
   WriteResult result = HandleResult(delegate_->Set(options, key, value));
   if (!result->status().ok())
     return result;
   SyncResultIfEnabled(result);
   return result;
 }
 
 ValueStore::WriteResult SyncableSettingsStorage::Set(
     WriteOptions options, const base::DictionaryValue& values) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(IsOnBackendSequence());
   WriteResult result = HandleResult(delegate_->Set(options, values));
   if (!result->status().ok())
     return result;
   SyncResultIfEnabled(result);
   return result;
 }
 
 ValueStore::WriteResult SyncableSettingsStorage::Remove(
     const std::string& key) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(IsOnBackendSequence());
   WriteResult result = HandleResult(delegate_->Remove(key));
   if (!result->status().ok())
     return result;
   SyncResultIfEnabled(result);
   return result;
 }
 
 ValueStore::WriteResult SyncableSettingsStorage::Remove(
     const std::vector<std::string>& keys) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(IsOnBackendSequence());
   WriteResult result = HandleResult(delegate_->Remove(keys));
   if (!result->status().ok())
     return result;
   SyncResultIfEnabled(result);
   return result;
 }
 
 ValueStore::WriteResult SyncableSettingsStorage::Clear() {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(IsOnBackendSequence());
   WriteResult result = HandleResult(delegate_->Clear());
   if (!result->status().ok())
     return result;
   SyncResultIfEnabled(result);
   return result;
 }
 
 void SyncableSettingsStorage::SyncResultIfEnabled(
     const ValueStore::WriteResult& result) {
   if (result->changes().empty())
     return;
 
   if (sync_processor_.get()) {
     syncer::SyncError error = sync_processor_->SendChanges(result->changes());
     if (error.IsSet())
       StopSyncing();
   } else {
     // Tell sync to try and start soon, because syncable changes to sync_type_
     // have started happening. This will cause sync to call us back
     // asynchronously via StartSyncing(...) as soon as possible.
     flare_.Run(sync_type_);
   }
 }
 
 // Sync-related methods.
 
 syncer::SyncError SyncableSettingsStorage::StartSyncing(
     std::unique_ptr<base::DictionaryValue> sync_state,
     std::unique_ptr<SettingsSyncProcessor> sync_processor) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(IsOnBackendSequence());
   DCHECK(sync_state);
   DCHECK(!sync_processor_.get());
 
   sync_processor_ = std::move(sync_processor);
   sync_processor_->Init(*sync_state);
 
   ReadResult maybe_settings = delegate_->Get();
   if (!maybe_settings->status().ok()) {
     return syncer::SyncError(
         FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
         base::StringPrintf("Failed to get settings: %s",
                            maybe_settings->status().message.c_str()),
         sync_processor_->type());
   }
 
   std::unique_ptr<base::DictionaryValue> current_settings =
       maybe_settings->PassSettings();
   return sync_state->empty()
              ? SendLocalSettingsToSync(std::move(current_settings))
              : OverwriteLocalSettingsWithSync(std::move(sync_state),
                                               std::move(current_settings));
 }
 
 syncer::SyncError SyncableSettingsStorage::SendLocalSettingsToSync(
     std::unique_ptr<base::DictionaryValue> local_state) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(IsOnBackendSequence());
 
   if (local_state->empty())
     return syncer::SyncError();
 
   // Transform the current settings into a list of sync changes.
   ValueStoreChangeList changes;
   while (!local_state->empty()) {
     // It's not possible to iterate over a DictionaryValue and modify it at the
     // same time, so hack around that restriction.
     std::string key = base::DictionaryValue::Iterator(*local_state).key();
     std::unique_ptr<base::Value> value;
     local_state->RemoveWithoutPathExpansion(key, &value);
     changes.push_back(ValueStoreChange(key, nullptr, std::move(value)));
   }
 
   syncer::SyncError error = sync_processor_->SendChanges(changes);
   if (error.IsSet())
     StopSyncing();
   return error;
 }
 
 syncer::SyncError SyncableSettingsStorage::OverwriteLocalSettingsWithSync(
     std::unique_ptr<base::DictionaryValue> sync_state,
     std::unique_ptr<base::DictionaryValue> local_state) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(IsOnBackendSequence());
   // This is implemented by building up a list of sync changes then sending
   // those to ProcessSyncChanges. This generates events like onStorageChanged.
   std::unique_ptr<SettingSyncDataList> changes(new SettingSyncDataList());
 
   for (base::DictionaryValue::Iterator it(*local_state); !it.IsAtEnd();
        it.Advance()) {
     std::unique_ptr<base::Value> sync_value;
     if (sync_state->RemoveWithoutPathExpansion(it.key(), &sync_value)) {
       if (sync_value->Equals(&it.value())) {
         // Sync and local values are the same, no changes to send.
@@ skipping 21 matching lines @@
     changes->push_back(base::MakeUnique<SettingSyncData>(
         syncer::SyncChange::ACTION_ADD, extension_id_, key, std::move(value)));
   }
 
   if (changes->empty())
     return syncer::SyncError();
   return ProcessSyncChanges(std::move(changes));
 }
 
 void SyncableSettingsStorage::StopSyncing() {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(IsOnBackendSequence());
   sync_processor_.reset();
 }
 
 syncer::SyncError SyncableSettingsStorage::ProcessSyncChanges(
     std::unique_ptr<SettingSyncDataList> sync_changes) {
-  DCHECK_CURRENTLY_ON(BrowserThread::FILE);
+  DCHECK(IsOnBackendSequence());
   DCHECK(!sync_changes->empty()) << "No sync changes for " << extension_id_;
 
   if (!sync_processor_.get()) {
     return syncer::SyncError(
         FROM_HERE,
         syncer::SyncError::DATATYPE_ERROR,
         std::string("Sync is inactive for ") + extension_id_,
         syncer::UNSPECIFIED);
   }
 
@@ skipping 128 matching lines @@
         FROM_HERE, syncer::SyncError::DATATYPE_ERROR,
         base::StringPrintf("Error pushing sync remove to local settings: %s",
                            result->status().message.c_str()),
         sync_processor_->type());
   }
   changes->push_back(ValueStoreChange(key, std::move(old_value), nullptr));
   return syncer::SyncError();
 }
 
 }  // namespace extensions