Remove WebVideoFrame, WebVideoFrameProvider, and WebVideoLayer.

webkit/media/webmediaplayer_ms.cc

 // Copyright (c) 2012 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/webmediaplayer_ms.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "cc/layers/video_layer.h"
 #include "media/base/media_log.h"
 #include "media/base/video_frame.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRect.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebSize.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebURL.h"
-#include "third_party/WebKit/Source/Platform/chromium/public/WebVideoFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaPlayerClient.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "webkit/compositor_bindings/web_layer_impl.h"
 #include "webkit/media/media_stream_audio_renderer.h"
 #include "webkit/media/media_stream_client.h"
 #include "webkit/media/video_frame_provider.h"
 #include "webkit/media/webmediaplayer_delegate.h"
 #include "webkit/media/webmediaplayer_util.h"
-#include "webkit/media/webvideoframe_impl.h"
 
 using WebKit::WebCanvas;
 using WebKit::WebMediaPlayer;
 using WebKit::WebRect;
 using WebKit::WebSize;
 
 namespace webkit_media {
 
 WebMediaPlayerMS::WebMediaPlayerMS(
     WebKit::WebFrame* frame,
@@ skipping 20 matching lines @@
   DVLOG(1) << "WebMediaPlayerMS::ctor";
   DCHECK(media_stream_client);
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_CREATED));
 }
 
 WebMediaPlayerMS::~WebMediaPlayerMS() {
   DVLOG(1) << "WebMediaPlayerMS::dtor";
   DCHECK(thread_checker_.CalledOnValidThread());
 
-#ifdef REMOVE_WEBVIDEOFRAME
   SetVideoFrameProviderClient(NULL);
   GetClient()->setWebLayer(NULL);
-#endif
 
   if (video_frame_provider_) {
     video_frame_provider_->Stop();
   }
 
   if (audio_renderer_) {
     if (audio_renderer_->IsLocalRenderer()) {
       audio_renderer_->Stop();
     } else if (!paused_) {
       // The |audio_renderer_| can be shared by multiple remote streams, and
@@ skipping 276 matching lines @@
   NOTIMPLEMENTED();
   return 0;
 }
 
 unsigned WebMediaPlayerMS::videoDecodedByteCount() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   NOTIMPLEMENTED();
   return 0;
 }
 
-#ifndef REMOVE_WEBVIDEOFRAME
-WebKit::WebVideoFrame* WebMediaPlayerMS::getCurrentFrame() {
-  DVLOG(3) << "WebMediaPlayerMS::getCurrentFrame";
-  base::AutoLock auto_lock(current_frame_lock_);
-  DCHECK(!pending_repaint_);
-  if (current_frame_.get()) {
-    pending_repaint_ = true;
-    current_frame_used_ = true;
-    return new webkit_media::WebVideoFrameImpl(current_frame_);
-  }
-  return NULL;
-}
-
-void WebMediaPlayerMS::putCurrentFrame(
-    WebKit::WebVideoFrame* web_video_frame) {
-  DVLOG(3) << "WebMediaPlayerMS::putCurrentFrame";
-  base::AutoLock auto_lock(current_frame_lock_);
-  DCHECK(pending_repaint_);
-  pending_repaint_ = false;
-  if (web_video_frame) {
-    delete web_video_frame;
-  }
-}
-#else
 void WebMediaPlayerMS::SetVideoFrameProviderClient(
     cc::VideoFrameProvider::Client* client) {
   // This is called from both the main renderer thread and the compositor
   // thread (when the main thread is blocked).
   if (video_frame_provider_client_)
     video_frame_provider_client_->StopUsingProvider();
   video_frame_provider_client_ = client;
 }
 
 scoped_refptr<media::VideoFrame> WebMediaPlayerMS::GetCurrentFrame() {
   DVLOG(3) << "WebMediaPlayerMS::GetCurrentFrame";
   base::AutoLock auto_lock(current_frame_lock_);
   DCHECK(!pending_repaint_);
   if (!current_frame_)
     return NULL;
   pending_repaint_ = true;
   current_frame_used_ = true;
   return current_frame_;
 }
 
 void WebMediaPlayerMS::PutCurrentFrame(
     const scoped_refptr<media::VideoFrame>& frame) {
   DVLOG(3) << "WebMediaPlayerMS::PutCurrentFrame";
   DCHECK(pending_repaint_);
   pending_repaint_ = false;
 }
-#endif
 
 void WebMediaPlayerMS::OnFrameAvailable(
     const scoped_refptr<media::VideoFrame>& frame) {
   DVLOG(3) << "WebMediaPlayerMS::OnFrameAvailable";
   DCHECK(thread_checker_.CalledOnValidThread());
   ++total_frame_count_;
   if (!received_first_frame_) {
     received_first_frame_ = true;
     {
       base::AutoLock auto_lock(current_frame_lock_);
       DCHECK(!current_frame_used_);
       current_frame_ =
           media::VideoFrame::CreateBlackFrame(frame->natural_size());
     }
     SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
     SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
     GetClient()->sizeChanged();
 
-#ifdef REMOVE_WEBVIDEOFRAME
     if (video_frame_provider_ && GetClient()->needsWebLayerForVideo()) {
       video_weblayer_.reset(
           new webkit::WebLayerImpl(cc::VideoLayer::Create(this)));
       GetClient()->setWebLayer(video_weblayer_.get());
     }
-#endif
   }
 
   // Do not update |current_frame_| when paused.
   if (paused_)
     return;
 
   if (!sequence_started_) {
     sequence_started_ = true;
     start_time_ = frame->GetTimestamp();
   }
@@ skipping 42 matching lines @@
   GetClient()->readyStateChanged();
 }
 
 WebKit::WebMediaPlayerClient* WebMediaPlayerMS::GetClient() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(client_);
   return client_;
 }
 
 }  // namespace webkit_media