[content/renderer] Convert VLOGs to DVLOGs

content/renderer/media/rtc_video_decoder_unittest.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 "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "content/renderer/media/rtc_video_decoder.h"
 #include "media/base/gmock_callback_support.h"
@@ skipping 30 matching lines @@
         .WillRepeatedly(Return(mock_vda_));
     EXPECT_CALL(*mock_gpu_factories_.get(), CreateSharedMemory(_))
         .WillRepeatedly(Return(static_cast<base::SharedMemory*>(NULL)));
     EXPECT_CALL(*mock_vda_, Initialize(_, _))
         .Times(1)
         .WillRepeatedly(Return(true));
     EXPECT_CALL(*mock_vda_, Destroy()).Times(1);
   }
 
   void TearDown() override {
-    VLOG(2) << "TearDown";
+    DVLOG(2) << "TearDown";
     EXPECT_TRUE(vda_thread_.IsRunning());
     RunUntilIdle();  // Wait until all callbascks complete.
     vda_task_runner_->DeleteSoon(FROM_HERE, rtc_decoder_.release());
     // Make sure the decoder is released before stopping the thread.
     RunUntilIdle();
     vda_thread_.Stop();
   }
 
   int32_t Decoded(webrtc::I420VideoFrame& decoded_image) override {
-    VLOG(2) << "Decoded";
+    DVLOG(2) << "Decoded";
     EXPECT_EQ(vda_task_runner_, base::MessageLoopProxy::current());
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
   void CreateDecoder(webrtc::VideoCodecType codec_type) {
-    VLOG(2) << "CreateDecoder";
+    DVLOG(2) << "CreateDecoder";
     codec_.codecType = codec_type;
     rtc_decoder_ =
         RTCVideoDecoder::Create(codec_type, mock_gpu_factories_);
   }
 
   void Initialize() {
-    VLOG(2) << "Initialize";
+    DVLOG(2) << "Initialize";
     EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK, rtc_decoder_->InitDecode(&codec_, 1));
     EXPECT_EQ(WEBRTC_VIDEO_CODEC_OK,
               rtc_decoder_->RegisterDecodeCompleteCallback(this));
   }
 
   void NotifyResetDone() {
-    VLOG(2) << "NotifyResetDone";
+    DVLOG(2) << "NotifyResetDone";
     vda_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&RTCVideoDecoder::NotifyResetDone,
                    base::Unretained(rtc_decoder_.get())));
   }
 
   void RunUntilIdle() {
-    VLOG(2) << "RunUntilIdle";
+    DVLOG(2) << "RunUntilIdle";
     vda_task_runner_->PostTask(FROM_HERE,
                                base::Bind(&base::WaitableEvent::Signal,
                                           base::Unretained(&idle_waiter_)));
     idle_waiter_.Wait();
   }
 
  protected:
   scoped_refptr<media::MockGpuVideoAcceleratorFactories> mock_gpu_factories_;
   media::MockVideoDecodeAccelerator* mock_vda_;
   scoped_ptr<RTCVideoDecoder> rtc_decoder_;
@@ skipping 122 matching lines @@
 
   EXPECT_FALSE(rtc_decoder_->IsFirstBufferAfterReset(RTCVideoDecoder::ID_LAST,
                                                      RTCVideoDecoder::ID_LAST));
   EXPECT_TRUE(
       rtc_decoder_->IsFirstBufferAfterReset(0, RTCVideoDecoder::ID_LAST));
   EXPECT_FALSE(
       rtc_decoder_->IsFirstBufferAfterReset(1, RTCVideoDecoder::ID_LAST));
 }
 
 }  // content