favor DCHECK_CURRENTLY_ON for better logs in content/browser

content/browser/media/capture/aura_window_capture_machine.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 "content/browser/media/capture/aura_window_capture_machine.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/timer/timer.h"
 #include "cc/output/copy_output_request.h"
@@ skipping 102 matching lines @@
 AuraWindowCaptureMachine::AuraWindowCaptureMachine()
     : desktop_window_(NULL),
       timer_(true, true),
       screen_capture_(false) {}
 
 AuraWindowCaptureMachine::~AuraWindowCaptureMachine() {}
 
 bool AuraWindowCaptureMachine::Start(
     const scoped_refptr<ThreadSafeCaptureOracle>& oracle_proxy,
     const media::VideoCaptureParams& params) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // The window might be destroyed between SetWindow() and Start().
   if (!desktop_window_)
     return false;
 
   // If the associated layer is already destroyed then return failure.
   ui::Layer* layer = desktop_window_->layer();
   if (!layer)
     return false;
 
@@ skipping 16 matching lines @@
 
   // Starts timer.
   timer_.Start(FROM_HERE, oracle_proxy_->min_capture_period(),
                base::Bind(&AuraWindowCaptureMachine::Capture, AsWeakPtr(),
                           false));
 
   return true;
 }
 
 void AuraWindowCaptureMachine::Stop(const base::Closure& callback) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   power_save_blocker_.reset();
 
   // Stop observing compositor and window events.
   if (desktop_window_) {
     aura::WindowTreeHost* window_host = desktop_window_->GetHost();
     // In the host destructor the compositor is destroyed before the window.
     if (window_host && window_host->compositor())
       window_host->compositor()->RemoveObserver(this);
     desktop_window_->RemoveObserver(this);
     desktop_window_ = NULL;
   }
 
   // Stop timer.
   timer_.Stop();
 
   callback.Run();
 }
 
 void AuraWindowCaptureMachine::SetWindow(aura::Window* window) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   DCHECK(!desktop_window_);
   desktop_window_ = window;
 
   // Start observing window events.
   desktop_window_->AddObserver(this);
 
   // We must store this for the UMA reporting in DidCopyOutput() as
   // desktop_window_ might be destroyed at that point.
   screen_capture_ = window->IsRootWindow();
   IncrementDesktopCaptureCounter(screen_capture_ ? SCREEN_CAPTURER_CREATED
                                                  : WINDOW_CAPTURER_CREATED);
 }
 
 void AuraWindowCaptureMachine::UpdateCaptureSize() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (oracle_proxy_.get() && desktop_window_) {
      ui::Layer* layer = desktop_window_->layer();
      oracle_proxy_->UpdateCaptureSize(ui::ConvertSizeToPixel(
          layer, layer->bounds().size()));
   }
   ClearCursorState();
 }
 
 void AuraWindowCaptureMachine::Capture(bool dirty) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Do not capture if the desktop window is already destroyed.
   if (!desktop_window_)
     return;
 
   scoped_refptr<media::VideoFrame> frame;
   ThreadSafeCaptureOracle::CaptureFrameCallback capture_frame_cb;
 
   const base::TimeTicks start_time = base::TimeTicks::Now();
   const VideoCaptureOracle::Event event =
@@ skipping 43 matching lines @@
                                          : FIRST_WINDOW_CAPTURE_FAILED);
     }
   }
 }
 
 bool AuraWindowCaptureMachine::ProcessCopyOutputResponse(
     scoped_refptr<media::VideoFrame> video_frame,
     base::TimeTicks start_time,
     const ThreadSafeCaptureOracle::CaptureFrameCallback& capture_frame_cb,
     scoped_ptr<cc::CopyOutputResult> result) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (result->IsEmpty() || result->size().IsEmpty() || !desktop_window_)
     return false;
 
   if (capture_params_.requested_format.pixel_format ==
       media::PIXEL_FORMAT_TEXTURE) {
     DCHECK(!video_frame.get());
     cc::TextureMailbox texture_mailbox;
     scoped_ptr<cc::SingleReleaseCallback> release_callback;
     result->TakeTexture(&texture_mailbox, &release_callback);
@@ skipping 133 matching lines @@
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds) {
   DCHECK(desktop_window_ && window == desktop_window_);
 
   // Post task to update capture size on UI thread.
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
       &AuraWindowCaptureMachine::UpdateCaptureSize, AsWeakPtr()));
 }
 
 void AuraWindowCaptureMachine::OnWindowDestroyed(aura::Window* window) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   Stop(base::Bind(&base::DoNothing));
 
   oracle_proxy_->ReportError("OnWindowDestroyed()");
 }
 
 void AuraWindowCaptureMachine::OnWindowAddedToRootWindow(
     aura::Window* window) {
   DCHECK(window == desktop_window_);
   window->GetHost()->compositor()->AddObserver(this);
 }
 
 void AuraWindowCaptureMachine::OnWindowRemovingFromRootWindow(
     aura::Window* window,
     aura::Window* new_root) {
   DCHECK(window == desktop_window_);
   window->GetHost()->compositor()->RemoveObserver(this);
 }
 
 void AuraWindowCaptureMachine::OnCompositingEnded(
     ui::Compositor* compositor) {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
       &AuraWindowCaptureMachine::Capture, AsWeakPtr(), true));
 }
 
 }  // namespace content