Rename TaskRunner::RunsTasksOnCurrentThread() in //net

net/http/transport_security_persister.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 "net/http/transport_security_persister.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/base64.h"
@@ skipping 288 matching lines @@
   transport_security_state_->SetDelegate(this);
 
   base::PostTaskAndReplyWithResult(
       background_runner_.get(), FROM_HERE,
       base::Bind(&LoadState, writer_.path()),
       base::Bind(&TransportSecurityPersister::CompleteLoad,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 TransportSecurityPersister::~TransportSecurityPersister() {
-  DCHECK(foreground_runner_->RunsTasksOnCurrentThread());
+  DCHECK(foreground_runner_->RunsTasksInCurrentSequence());
 
   if (writer_.HasPendingWrite())
     writer_.DoScheduledWrite();
 
   transport_security_state_->SetDelegate(NULL);
 }
 
 void TransportSecurityPersister::StateIsDirty(TransportSecurityState* state) {
-  DCHECK(foreground_runner_->RunsTasksOnCurrentThread());
+  DCHECK(foreground_runner_->RunsTasksInCurrentSequence());
   DCHECK_EQ(transport_security_state_, state);
 
   if (!readonly_)
     writer_.ScheduleWrite(this);
 }
 
 bool TransportSecurityPersister::SerializeData(std::string* output) {
-  DCHECK(foreground_runner_->RunsTasksOnCurrentThread());
+  DCHECK(foreground_runner_->RunsTasksInCurrentSequence());
 
   base::DictionaryValue toplevel;
 
   // TODO(davidben): Fix the serialization format by splitting the on-disk
   // representation of the STS and PKP states. https://crbug.com/470295.
   SerializeSTSData(transport_security_state_, &toplevel);
   SerializePKPData(transport_security_state_, &toplevel);
   SerializeExpectCTData(transport_security_state_, &toplevel);
 
   base::JSONWriter::WriteWithOptions(
       toplevel, base::JSONWriter::OPTIONS_PRETTY_PRINT, output);
   return true;
 }
 
 bool TransportSecurityPersister::LoadEntries(const std::string& serialized,
                                              bool* dirty) {
-  DCHECK(foreground_runner_->RunsTasksOnCurrentThread());
+  DCHECK(foreground_runner_->RunsTasksInCurrentSequence());
 
   transport_security_state_->ClearDynamicData();
   return Deserialize(serialized, dirty, transport_security_state_);
 }
 
 // static
 bool TransportSecurityPersister::Deserialize(const std::string& serialized,
                                              bool* dirty,
                                              TransportSecurityState* state) {
   std::unique_ptr<base::Value> value = base::JSONReader::Read(serialized);
@@ skipping 130 matching lines @@
       state->AddOrUpdateEnabledPKPHosts(hashed, pkp_state);
     if (has_expect_ct)
       state->AddOrUpdateEnabledExpectCTHosts(hashed, expect_ct_state);
   }
 
   *dirty = dirtied;
   return true;
 }
 
 void TransportSecurityPersister::CompleteLoad(const std::string& state) {
-  DCHECK(foreground_runner_->RunsTasksOnCurrentThread());
+  DCHECK(foreground_runner_->RunsTasksInCurrentSequence());
 
   if (state.empty())
     return;
 
   bool dirty = false;
   if (!LoadEntries(state, &dirty)) {
     LOG(ERROR) << "Failed to deserialize state: " << state;
     return;
   }
   if (dirty)
     StateIsDirty(transport_security_state_);
 }
 
 }  // namespace net