Remove WebVideoFrame, WebVideoFrameProvider, and WebVideoLayer.

webkit/media/webmediaplayer_impl.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_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <string>
 #include <vector>
@@ skipping 25 matching lines @@
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "v8/include/v8.h"
 #include "webkit/compositor_bindings/web_layer_impl.h"
 #include "webkit/media/buffered_data_source.h"
 #include "webkit/media/filter_helpers.h"
 #include "webkit/media/webaudiosourceprovider_impl.h"
 #include "webkit/media/webmediaplayer_delegate.h"
 #include "webkit/media/webmediaplayer_params.h"
 #include "webkit/media/webmediaplayer_util.h"
 #include "webkit/media/webmediasourceclient_impl.h"
-#include "webkit/media/webvideoframe_impl.h"
 #include "webkit/plugins/ppapi/ppapi_webplugin_impl.h"
 
 using WebKit::WebCanvas;
 using WebKit::WebMediaPlayer;
 using WebKit::WebRect;
 using WebKit::WebSize;
 using WebKit::WebString;
 using media::PipelineStatus;
 
 namespace {
@@ skipping 155 matching lines @@
   scoped_ptr<media::AudioRenderer> audio_renderer(
       new media::AudioRendererImpl(
         media_thread_.message_loop_proxy(),
         audio_source_provider_,
         audio_decoders.Pass(),
         set_decryptor_ready_cb));
   filter_collection_->SetAudioRenderer(audio_renderer.Pass());
 }
 
 WebMediaPlayerImpl::~WebMediaPlayerImpl() {
-#ifdef REMOVE_WEBVIDEOFRAME
   SetVideoFrameProviderClient(NULL);
   GetClient()->setWebLayer(NULL);
-#endif
 
   DCHECK(main_loop_->BelongsToCurrentThread());
   Destroy();
   media_log_->AddEvent(
       media_log_->CreateEvent(media::MediaLogEvent::WEBMEDIAPLAYER_DESTROYED));
 
   if (delegate_)
     delegate_->PlayerGone(this);
 
   // Remove destruction observer if we're being destroyed but the main thread is
@@ skipping 426 matching lines @@
   return stats.audio_bytes_decoded;
 }
 
 unsigned WebMediaPlayerImpl::videoDecodedByteCount() const {
   DCHECK(main_loop_->BelongsToCurrentThread());
 
   media::PipelineStatistics stats = pipeline_->GetStatistics();
   return stats.video_bytes_decoded;
 }
 
-#ifndef REMOVE_WEBVIDEOFRAME
-WebKit::WebVideoFrame* WebMediaPlayerImpl::getCurrentFrame() {
-  base::AutoLock auto_lock(lock_);
-  if (current_frame_)
-    return new WebVideoFrameImpl(current_frame_);
-  return NULL;
-}
-
-void WebMediaPlayerImpl::putCurrentFrame(
-    WebKit::WebVideoFrame* web_video_frame) {
-  if (!accelerated_compositing_reported_) {
-    accelerated_compositing_reported_ = true;
-    DCHECK(frame_->view()->isAcceleratedCompositingActive());
-    UMA_HISTOGRAM_BOOLEAN("Media.AcceleratedCompositingActive", true);
-  }
-  delete web_video_frame;
-}
-#else
 void WebMediaPlayerImpl::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> WebMediaPlayerImpl::GetCurrentFrame() {
   base::AutoLock auto_lock(lock_);
   return current_frame_;
 }
 
 void WebMediaPlayerImpl::PutCurrentFrame(
     const scoped_refptr<media::VideoFrame>& frame) {
   if (!accelerated_compositing_reported_) {
     accelerated_compositing_reported_ = true;
     DCHECK(frame_->view()->isAcceleratedCompositingActive());
     UMA_HISTOGRAM_BOOLEAN("Media.AcceleratedCompositingActive", true);
   }
 }
-#endif
 
 bool WebMediaPlayerImpl::copyVideoTextureToPlatformTexture(
     WebKit::WebGraphicsContext3D* web_graphics_context,
     unsigned int texture,
     unsigned int level,
     unsigned int internal_format,
     bool premultiply_alpha,
     bool flip_y) {
   scoped_refptr<media::VideoFrame> video_frame;
   {
@@ skipping 271 matching lines @@
 }
 
 void WebMediaPlayerImpl::OnPipelineBufferingState(
     media::Pipeline::BufferingState buffering_state) {
   DVLOG(1) << "OnPipelineBufferingState(" << buffering_state << ")";
 
   switch (buffering_state) {
     case media::Pipeline::kHaveMetadata:
       SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
 
-#ifdef REMOVE_WEBVIDEOFRAME
       if (hasVideo() && GetClient()->needsWebLayerForVideo()) {
         DCHECK(!video_weblayer_);
         video_weblayer_.reset(
             new webkit::WebLayerImpl(cc::VideoLayer::Create(this)));
         GetClient()->setWebLayer(video_weblayer_.get());
       }
-#endif
       break;
     case media::Pipeline::kPrerollCompleted:
       SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
       break;
   }
 
   // Repaint to trigger UI update.
   Repaint();
 }
 
@@ skipping 132 matching lines @@
   DVLOG(1) << "SetNetworkState: " << state;
   network_state_ = state;
   // Always notify to ensure client has the latest value.
   GetClient()->networkStateChanged();
 }
 
 void WebMediaPlayerImpl::SetReadyState(WebMediaPlayer::ReadyState state) {
   DCHECK(main_loop_->BelongsToCurrentThread());
   DVLOG(1) << "SetReadyState: " << state;
 
-#ifndef REMOVE_WEBVIDEOFRAME
-  if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing &&
-      state >= WebMediaPlayer::ReadyStateHaveMetadata) {
-    if (!hasVideo())
-      GetClient()->disableAcceleratedCompositing();
-  } else
-#endif
   if (state == WebMediaPlayer::ReadyStateHaveEnoughData &&
       is_local_source_ &&
       network_state_ == WebMediaPlayer::NetworkStateLoading)
     SetNetworkState(WebMediaPlayer::NetworkStateLoaded);
 
   ready_state_ = state;
   // Always notify to ensure client has the latest value.
   GetClient()->readyStateChanged();
 }
 
@@ skipping 67 matching lines @@
 
   if (pending_repaint_)
     return;
 
   pending_repaint_ = true;
   main_loop_->PostTask(FROM_HERE, base::Bind(
       &WebMediaPlayerImpl::Repaint, AsWeakPtr()));
 }
 
 }  // namespace webkit_media