Rename TaskRunner::RunsTasksOnCurrentThread() in //components

components/browser_sync/profile_sync_service_autofill_unittest.cc

 // Copyright 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 <stdint.h>
 
 #include <memory>
 #include <set>
 #include <string>
@@ skipping 178 matching lines @@
         ui_thread_(ui_thread) {}
 
   ~MockAutofillBackend() override {}
   WebDatabase* GetDatabase() override { return web_database_; }
   void AddObserver(
       autofill::AutofillWebDataServiceObserverOnDBThread* observer) override {}
   void RemoveObserver(
       autofill::AutofillWebDataServiceObserverOnDBThread* observer) override {}
   void RemoveExpiredFormElements() override {}
   void NotifyOfMultipleAutofillChanges() override {
-    DCHECK(!ui_thread_->RunsTasksOnCurrentThread());
+    DCHECK(!ui_thread_->RunsTasksInCurrentSequence());
     ui_thread_->PostTask(FROM_HERE, on_changed_);
   }
   void NotifyThatSyncHasStarted(syncer::ModelType model_type) override {
-    DCHECK(!ui_thread_->RunsTasksOnCurrentThread());
+    DCHECK(!ui_thread_->RunsTasksInCurrentSequence());
     ui_thread_->PostTask(FROM_HERE, base::Bind(on_sync_started_, model_type));
   }
 
  private:
   WebDatabase* web_database_;
   base::Closure on_changed_;
   base::Callback<void(syncer::ModelType)> on_sync_started_;
   const scoped_refptr<base::SequencedTaskRunner> ui_thread_;
 };
 
@@ skipping 111 matching lines @@
                          base::Bind(&RunAndSignal, notify_cb, &event));
     event.Wait();
   }
 
  private:
   ~WebDataServiceFake() override {}
 
   void CreateSyncableService(
       const base::Closure& on_changed_callback,
       const base::Callback<void(syncer::ModelType)>& on_sync_started) {
-    ASSERT_TRUE(db_thread_->RunsTasksOnCurrentThread());
+    ASSERT_TRUE(db_thread_->RunsTasksInCurrentSequence());
     // These services are deleted in DestroySyncableService().
     backend_ = base::MakeUnique<MockAutofillBackend>(
         GetDatabase(), on_changed_callback, on_sync_started, ui_thread_.get());
     AutocompleteSyncableService::CreateForWebDataServiceAndBackend(
         this, backend_.get());
     AutofillProfileSyncableService::CreateForWebDataServiceAndBackend(
         this, backend_.get(), "en-US");
 
     autocomplete_syncable_service_ =
         AutocompleteSyncableService::FromWebDataService(this);
     autofill_profile_syncable_service_ =
         AutofillProfileSyncableService::FromWebDataService(this);
 
     syncable_service_created_or_destroyed_.Signal();
   }
 
   void DestroySyncableService() {
-    ASSERT_TRUE(db_thread_->RunsTasksOnCurrentThread());
+    ASSERT_TRUE(db_thread_->RunsTasksInCurrentSequence());
     autocomplete_syncable_service_ = nullptr;
     autofill_profile_syncable_service_ = nullptr;
     backend_.reset();
     syncable_service_created_or_destroyed_.Signal();
   }
 
   WebDatabase* web_database_;
   AutocompleteSyncableService* autocomplete_syncable_service_;
   AutofillProfileSyncableService* autofill_profile_syncable_service_;
   std::unique_ptr<autofill::AutofillWebDataBackend> backend_;
@@ skipping 369 matching lines @@
       : entry_(MakeAutofillEntry("0", "0", 0)),
         service_(service),
         wait_for_start_(wait_for_start),
         wait_for_syncapi_(wait_for_syncapi),
         is_finished_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                      base::WaitableEvent::InitialState::NOT_SIGNALED),
         db_thread_(db_thread) {}
 
   void Update() {
     // This gets called in a modelsafeworker thread.
-    ASSERT_TRUE(db_thread_->RunsTasksOnCurrentThread());
+    ASSERT_TRUE(db_thread_->RunsTasksInCurrentSequence());
 
     syncer::UserShare* user_share = service_->GetUserShare();
     syncer::syncable::Directory* directory = user_share->directory.get();
 
     // Create autofill protobuf.
     std::string tag = AutocompleteSyncableService::KeyToTag(
         base::UTF16ToUTF8(entry_.key().name()),
         base::UTF16ToUTF8(entry_.key().value()));
     sync_pb::AutofillSpecifics new_autofill;
     new_autofill.set_name(base::UTF16ToUTF8(entry_.key().name()));
@@ skipping 28 matching lines @@
       item.PutId(server_item_id);
       syncer::syncable::Id new_predecessor;
       ASSERT_TRUE(item.PutPredecessor(new_predecessor));
     }
     DVLOG(1) << "FakeServerUpdater finishing.";
     is_finished_.Signal();
   }
 
   void CreateNewEntry(const AutofillEntry& entry) {
     entry_ = entry;
-    ASSERT_FALSE(db_thread_->RunsTasksOnCurrentThread());
+    ASSERT_FALSE(db_thread_->RunsTasksInCurrentSequence());
     if (!db_thread_->PostTask(FROM_HERE,
                               base::Bind(&FakeServerUpdater::Update, this))) {
       NOTREACHED() << "Failed to post task to the db thread.";
       return;
     }
   }
 
   void WaitForUpdateCompletion() { is_finished_.Wait(); }
 
  private:
@@ skipping 750 matching lines @@
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&sync_entries, &sync_profiles));
   EXPECT_EQ(3U, sync_entries.size());
   EXPECT_EQ(0U, sync_profiles.size());
   for (size_t i = 0; i < sync_entries.size(); i++) {
     DVLOG(1) << "Entry " << i << ": " << sync_entries[i].key().name() << ", "
              << sync_entries[i].key().value();
   }
 }
 
 }  // namespace browser_sync