Remove --enable-video-logging and WebVideoRenderer.

webkit/media/video_renderer_impl.cc

 // Copyright (c) 2011 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 "webkit/media/video_renderer_impl.h"
 
 #include "base/logging.h"
 #include "media/base/video_frame.h"
 #include "media/base/yuv_convert.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "webkit/media/webmediaplayer_proxy.h"
 
 namespace webkit_media {
 
-VideoRendererImpl::VideoRendererImpl(bool pts_logging)
-    : last_converted_frame_(NULL),
-      pts_logging_(pts_logging) {
+VideoRendererImpl::VideoRendererImpl(
+    const scoped_refptr<WebMediaPlayerProxy>& proxy)
+    : proxy_(proxy),
+      last_converted_frame_(NULL) {
 }
 
 VideoRendererImpl::~VideoRendererImpl() {}
 
 bool VideoRendererImpl::OnInitialize(media::VideoDecoder* decoder) {
   natural_size_ = decoder->natural_size();
   bitmap_.setConfig(SkBitmap::kARGB_8888_Config,
                     natural_size_.width(), natural_size_.height());
   bitmap_.allocPixels();
   bitmap_.eraseRGB(0x00, 0x00, 0x00);
   bitmap_.setIsVolatile(true);
   return true;
 }
 
 void VideoRendererImpl::OnStop(const base::Closure& callback) {
   if (!callback.is_null())
     callback.Run();
 }
 
 void VideoRendererImpl::OnFrameAvailable() {
   proxy_->Repaint();
 }
 
-void VideoRendererImpl::SetWebMediaPlayerProxy(WebMediaPlayerProxy* proxy) {
-  proxy_ = proxy;
-}
-
-void VideoRendererImpl::SetRect(const gfx::Rect& rect) {}
-
 // This method is always called on the renderer's thread.
 void VideoRendererImpl::Paint(SkCanvas* canvas, const gfx::Rect& dest_rect) {
   scoped_refptr<media::VideoFrame> video_frame;
   GetCurrentFrame(&video_frame);
   if (!video_frame) {
     SkPaint paint;
     paint.setColor(SK_ColorBLACK);
     canvas->drawRectCoords(
         static_cast<float>(dest_rect.x()),
         static_cast<float>(dest_rect.y()),
         static_cast<float>(dest_rect.right()),
         static_cast<float>(dest_rect.bottom()),
         paint);
   } else {
     if (CanFastPaint(canvas, dest_rect)) {
       FastPaint(video_frame, canvas, dest_rect);
     } else {
       SlowPaint(video_frame, canvas, dest_rect);
     }
-
-    // Presentation timestamp logging is primarily used to measure performance
-    // on low-end devices.  When profiled on an Intel Atom N280 @ 1.66GHz this
-    // code had a ~63 microsecond perf hit when logging to a file (not stdout),
-    // which is neglible enough for measuring playback performance.
-    if (pts_logging_)
-      VLOG(1) << "pts=" << video_frame->GetTimestamp().InMicroseconds();
   }
 
   PutCurrentFrame(video_frame);
 }
 
 // CanFastPaint is a helper method to determine the conditions for fast
 // painting. The conditions are:
 // 1. No skew in canvas matrix.
 // 2. No flipping nor mirroring.
 // 3. Canvas has pixel format ARGB8888.
@@ skipping 185 matching lines @@
                            video_frame->stride(media::VideoFrame::kUPlane),
                            bitmap.rowBytes(),
                            yuv_type,
                            media::ROTATE_0,
                            media::FILTER_BILINEAR);
     bitmap.unlockPixels();
   }
 }
 
 }  // namespace webkit_media