Remove calls to IsRunningSequenceOnCurrentThread() from crash_handler_host_linux.cc

components/crash/content/browser/crash_handler_host_linux.cc

 // Copyright 2013 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 "components/crash/content/browser/crash_handler_host_linux.h"
 
 #include <errno.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ skipping 83 matching lines @@
 CrashHandlerHostLinux::CrashHandlerHostLinux(const std::string& process_type,
                                              const base::FilePath& dumps_path,
                                              bool upload)
     : process_type_(process_type),
       dumps_path_(dumps_path),
 #if !defined(OS_ANDROID)
       upload_(upload),
 #endif
       shutting_down_(false),
       worker_pool_token_(base::SequencedWorkerPool::GetSequenceToken()) {
+  write_dump_file_sequence_checker_.DetachFromSequence();
+
   int fds[2];
   // We use SOCK_SEQPACKET rather than SOCK_DGRAM to prevent the process from
   // sending datagrams to other sockets on the system. The sandbox may prevent
   // the process from calling socket() to create new sockets, but it'll still
   // inherit some sockets. With PF_UNIX+SOCK_DGRAM, it can call sendmsg to send
   // a datagram to any (abstract) socket on the same system. With
   // SOCK_SEQPACKET, this is prevented.
   CHECK_EQ(0, socketpair(AF_UNIX, SOCK_SEQPACKET, 0, fds));
   static const int on = 1;
 
@@ skipping 280 matching lines @@
                  base::Passed(&info),
                  base::Passed(&crash_context),
                  crashing_pid,
                  signal_fd));
 }
 
 void CrashHandlerHostLinux::WriteDumpFile(std::unique_ptr<BreakpadInfo> info,
                                           std::unique_ptr<char[]> crash_context,
                                           pid_t crashing_pid,
                                           int signal_fd) {
-  DCHECK(BrowserThread::GetBlockingPool()->IsRunningSequenceOnCurrentThread(
-      worker_pool_token_));
+  DCHECK(write_dump_file_sequence_checker_.CalledOnValidSequence());
 
   // Set |info->distro| here because base::GetLinuxDistro() needs to run on a
   // blocking thread.
   std::string distro = base::GetLinuxDistro();
   info->distro_length = distro.length();
   // Freed in CrashDumpTask().
   char* distro_str = new char[info->distro_length + 1];
   distro.copy(distro_str, info->distro_length);
   distro_str[info->distro_length] = '\0';
   info->distro = distro_str;
@@ skipping 75 matching lines @@
   // no-ops.
   shutting_down_ = true;
   uploader_thread_->Stop();
 }
 
 bool CrashHandlerHostLinux::IsShuttingDown() const {
   return shutting_down_;
 }
 
 }  // namespace breakpad