[chrome/browser/media] favor DCHECK_CURRENTLY_ON for better logs

chrome/browser/media/webrtc_rtp_dump_handler.cc

 // Copyright 2014 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/media/webrtc_rtp_dump_handler.h"
 
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/media/webrtc_rtp_dump_writer.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace {
 
 static const size_t kMaxOngoingRtpDumpsAllowed = 5;
 
 // The browser process wide total number of ongoing (i.e. started and not
 // released) RTP dumps. Incoming and outgoing in one WebRtcDumpHandler are
 // counted as one dump.
 // Must be accessed on the browser IO thread.
 static size_t g_ongoing_rtp_dumps = 0;
 
 void FireGenericDoneCallback(
     const WebRtcRtpDumpHandler::GenericDoneCallback& callback,
     bool success,
     const std::string& error_message) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!callback.is_null());
 
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(callback, success, error_message));
 }
 
 bool DumpTypeContainsIncoming(RtpDumpType type) {
   return type == RTP_DUMP_INCOMING || type == RTP_DUMP_BOTH;
 }
 
 bool DumpTypeContainsOutgoing(RtpDumpType type) {
   return type == RTP_DUMP_OUTGOING || type == RTP_DUMP_BOTH;
 }
 
 }  // namespace
 
 WebRtcRtpDumpHandler::WebRtcRtpDumpHandler(const base::FilePath& dump_dir)
     : dump_dir_(dump_dir),
       incoming_state_(STATE_NONE),
       outgoing_state_(STATE_NONE),
       weak_ptr_factory_(this) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 }
 
 WebRtcRtpDumpHandler::~WebRtcRtpDumpHandler() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Reset dump writer first to stop writing.
   if (dump_writer_) {
     --g_ongoing_rtp_dumps;
     dump_writer_.reset();
   }
 
   if (incoming_state_ != STATE_NONE && !incoming_dump_path_.empty()) {
     BrowserThread::PostTask(
         BrowserThread::FILE,
         FROM_HERE,
         base::Bind(
             base::IgnoreResult(&base::DeleteFile), incoming_dump_path_, false));
   }
 
   if (outgoing_state_ != STATE_NONE && !outgoing_dump_path_.empty()) {
     BrowserThread::PostTask(
         BrowserThread::FILE,
         FROM_HERE,
         base::Bind(
             base::IgnoreResult(&base::DeleteFile), outgoing_dump_path_, false));
   }
 }
 
 bool WebRtcRtpDumpHandler::StartDump(RtpDumpType type,
                                      std::string* error_message) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!dump_writer_ && g_ongoing_rtp_dumps >= kMaxOngoingRtpDumpsAllowed) {
     *error_message = "Max RTP dump limit reached.";
     DVLOG(2) << *error_message;
     return false;
   }
 
   // Returns an error if any type of dump specified by the caller cannot be
   // started.
   if ((DumpTypeContainsIncoming(type) && incoming_state_ != STATE_NONE) ||
@@ skipping 37 matching lines @@
         kMaxDumpSize,
         base::Bind(&WebRtcRtpDumpHandler::OnMaxDumpSizeReached,
                    base::Unretained(this))));
   }
 
   return true;
 }
 
 void WebRtcRtpDumpHandler::StopDump(RtpDumpType type,
                                     const GenericDoneCallback& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Returns an error if any type of dump specified by the caller cannot be
   // stopped.
   if ((DumpTypeContainsIncoming(type) && incoming_state_ != STATE_STARTED) ||
       (DumpTypeContainsOutgoing(type) && outgoing_state_ != STATE_STARTED)) {
     if (!callback.is_null()) {
       FireGenericDoneCallback(
           callback,
           false,
           "RTP dump not started or already stopped for type " +
@@ skipping 17 matching lines @@
       type,
       base::Bind(&WebRtcRtpDumpHandler::OnDumpEnded,
                  base::Unretained(this),
                  callback.is_null()
                      ? base::Closure()
                      : base::Bind(&FireGenericDoneCallback, callback, true, ""),
                  type));
 }
 
 bool WebRtcRtpDumpHandler::ReadyToRelease() const {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   return incoming_state_ != STATE_STARTED &&
          incoming_state_ != STATE_STOPPING &&
          outgoing_state_ != STATE_STARTED && outgoing_state_ != STATE_STOPPING;
 }
 
 WebRtcRtpDumpHandler::ReleasedDumps WebRtcRtpDumpHandler::ReleaseDumps() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(ReadyToRelease());
 
   base::FilePath incoming_dump, outgoing_dump;
 
   if (incoming_state_ == STATE_STOPPED) {
     DVLOG(2) << "Incoming RTP dumps released: " << incoming_dump_path_.value();
 
     incoming_state_ = STATE_NONE;
     incoming_dump = incoming_dump_path_;
   }
 
   if (outgoing_state_ == STATE_STOPPED) {
     DVLOG(2) << "Outgoing RTP dumps released: " << outgoing_dump_path_.value();
 
     outgoing_state_ = STATE_NONE;
     outgoing_dump = outgoing_dump_path_;
   }
   return ReleasedDumps(incoming_dump, outgoing_dump);
 }
 
 void WebRtcRtpDumpHandler::OnRtpPacket(const uint8* packet_header,
                                        size_t header_length,
                                        size_t packet_length,
                                        bool incoming) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if ((incoming && incoming_state_ != STATE_STARTED) ||
       (!incoming && outgoing_state_ != STATE_STARTED)) {
     return;
   }
 
   dump_writer_->WriteRtpPacket(
       packet_header, header_length, packet_length, incoming);
 }
 
 void WebRtcRtpDumpHandler::StopOngoingDumps(const base::Closure& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!callback.is_null());
 
   // No ongoing dumps, return directly.
   if ((incoming_state_ == STATE_NONE || incoming_state_ == STATE_STOPPED) &&
       (outgoing_state_ == STATE_NONE || outgoing_state_ == STATE_STOPPED)) {
     callback.Run();
     return;
   }
 
   // If the FILE thread is working on stopping the dumps, wait for the FILE
@@ skipping 26 matching lines @@
 
   dump_writer_->EndDump(type,
                         base::Bind(&WebRtcRtpDumpHandler::OnDumpEnded,
                                    base::Unretained(this),
                                    callback,
                                    type));
 }
 
 void WebRtcRtpDumpHandler::SetDumpWriterForTesting(
     scoped_ptr<WebRtcRtpDumpWriter> writer) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   dump_writer_ = writer.Pass();
   ++g_ongoing_rtp_dumps;
 
   incoming_dump_path_ = dump_dir_.AppendASCII("recv");
   outgoing_dump_path_ = dump_dir_.AppendASCII("send");
 }
 
 void WebRtcRtpDumpHandler::OnMaxDumpSizeReached() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   RtpDumpType type =
       (incoming_state_ == STATE_STARTED)
           ? (outgoing_state_ == STATE_STARTED ? RTP_DUMP_BOTH
                                               : RTP_DUMP_INCOMING)
           : RTP_DUMP_OUTGOING;
   StopDump(type, GenericDoneCallback());
 }
 
 void WebRtcRtpDumpHandler::OnDumpEnded(const base::Closure& callback,
                                        RtpDumpType ended_type,
                                        bool incoming_success,
                                        bool outgoing_success) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (DumpTypeContainsIncoming(ended_type)) {
     DCHECK_EQ(STATE_STOPPING, incoming_state_);
     incoming_state_ = STATE_STOPPED;
 
     if (!incoming_success) {
       BrowserThread::PostTask(BrowserThread::FILE,
                               FROM_HERE,
                               base::Bind(base::IgnoreResult(&base::DeleteFile),
                                          incoming_dump_path_,
@@ skipping 26 matching lines @@
   if (incoming_state_ != STATE_STOPPING && outgoing_state_ != STATE_STOPPING &&
       incoming_state_ != STATE_STARTED && outgoing_state_ != STATE_STARTED) {
     dump_writer_.reset();
     --g_ongoing_rtp_dumps;
   }
 
   // This object might be deleted after running the callback.
   if (!callback.is_null())
     callback.Run();
 }