Use DCHECK_CURRENTLY_ON in content/

content/browser/tracing/tracing_controller_impl_data_sinks.cc

 // Copyright 2015 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 "content/browser/tracing/tracing_controller_impl.h"
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "third_party/zlib/zlib.h"
 
@@ skipping 181 matching lines @@
   void Close() override {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(&CompressedStringTraceDataSink::CloseOnFileThread, this));
   }
 
  private:
   ~CompressedStringTraceDataSink() override {}
 
   bool OpenZStreamOnFileThread() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+    DCHECK_CURRENTLY_ON(BrowserThread::FILE);
     if (stream_)
       return true;
 
     if (already_tried_open_)
       return false;
 
     already_tried_open_ = true;
     stream_.reset(new z_stream);
     *stream_ = {0};
     stream_->zalloc = Z_NULL;
     stream_->zfree = Z_NULL;
     stream_->opaque = Z_NULL;
 
     int result = deflateInit2(stream_.get(), Z_DEFAULT_COMPRESSION, Z_DEFLATED,
                               // 16 is added to produce a gzip header + trailer.
                               MAX_WBITS + 16,
                               8,  // memLevel = 8 is default.
                               Z_DEFAULT_STRATEGY);
     return result == 0;
   }
 
   void AddTraceChunkOnFileThread(
       const scoped_refptr<base::RefCountedString> chunk_ptr) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+    DCHECK_CURRENTLY_ON(BrowserThread::FILE);
     std::string trace;
     if (compressed_trace_data_.empty())
       trace = "{\"traceEvents\":[";
     else
       trace = ",";
     trace += chunk_ptr->data();
     AddTraceChunkAndCompressOnFileThread(trace, false);
   }
 
   void AddTraceChunkAndCompressOnFileThread(const std::string& chunk,
                                             bool finished) {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+    DCHECK_CURRENTLY_ON(BrowserThread::FILE);
     if (!OpenZStreamOnFileThread())
       return;
 
     const int kChunkSize = 0x4000;
 
     char buffer[kChunkSize];
     int err;
     stream_->avail_in = chunk.size();
     stream_->next_in = (unsigned char*)chunk.data();
     do {
       stream_->avail_out = kChunkSize;
       stream_->next_out = (unsigned char*)buffer;
       err = deflate(stream_.get(), finished ? Z_FINISH : Z_NO_FLUSH);
       if (err != Z_OK && (err != Z_STREAM_END && finished)) {
         stream_.reset();
         return;
       }
 
       int bytes = kChunkSize - stream_->avail_out;
       if (bytes) {
         std::string compressed_chunk = std::string(buffer, bytes);
         compressed_trace_data_ += compressed_chunk;
         endpoint_->ReceiveTraceChunk(compressed_chunk);
       }
     } while (stream_->avail_out == 0);
   }
 
   void CloseOnFileThread() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+    DCHECK_CURRENTLY_ON(BrowserThread::FILE);
     if (!OpenZStreamOnFileThread())
       return;
 
     if (compressed_trace_data_.empty())
       AddTraceChunkAndCompressOnFileThread("{\"traceEvents\":[", false);
 
     AddTraceChunkAndCompressOnFileThread("]", false);
     if (!system_trace_.empty()) {
       AddTraceChunkAndCompressOnFileThread(
           ",\"systemTraceEvents\": " + system_trace_, false);
@@ skipping 52 matching lines @@
   return new StringTraceDataEndpoint(callback);
 }
 
 scoped_refptr<TracingController::TraceDataEndpoint>
 TracingController::CreateFileEndpoint(const base::FilePath& file_path,
                                       const base::Closure& callback) {
   return new FileTraceDataEndpoint(file_path, callback);
 }
 
 }  // namespace content