Remove WebVideoFrame, WebVideoFrameProvider, and WebVideoLayer.

webkit/media/android/webmediaplayer_android.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/android/webmediaplayer_android.h"
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "cc/layers/video_layer.h"
 #include "media/base/android/media_player_bridge.h"
 #include "media/base/video_frame.h"
 #include "net/base/mime_util.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaPlayerClient.h"
 #include "webkit/compositor_bindings/web_layer_impl.h"
 #include "webkit/media/android/stream_texture_factory_android.h"
 #include "webkit/media/android/webmediaplayer_manager_android.h"
 #include "webkit/media/media_switches.h"
 #include "webkit/media/webmediaplayer_util.h"
-#include "webkit/media/webvideoframe_impl.h"
 
 static const uint32 kGLTextureExternalOES = 0x8D65;
 
 using WebKit::WebMediaPlayer;
 using WebKit::WebMediaSource;
 using WebKit::WebSize;
 using WebKit::WebTimeRanges;
 using WebKit::WebURL;
-using WebKit::WebVideoFrame;
 using media::MediaPlayerBridge;
 using media::VideoFrame;
 
 namespace webkit_media {
 
 WebMediaPlayerAndroid::WebMediaPlayerAndroid(
     WebKit::WebMediaPlayerClient* client,
     WebMediaPlayerManagerAndroid* manager,
     StreamTextureFactory* factory)
     : client_(client),
@@ skipping 21 matching lines @@
     SetNeedsEstablishPeer(false);
     ReallocateVideoFrame();
   } else if (stream_texture_factory_.get()) {
     stream_texture_proxy_.reset(stream_texture_factory_->CreateProxy());
     stream_id_ = stream_texture_factory_->CreateStreamTexture(&texture_id_);
     ReallocateVideoFrame();
   }
 }
 
 WebMediaPlayerAndroid::~WebMediaPlayerAndroid() {
-#ifdef REMOVE_WEBVIDEOFRAME
   SetVideoFrameProviderClient(NULL);
   client_->setWebLayer(NULL);
-#endif
 
   if (stream_id_)
     stream_texture_factory_->DestroyStreamTexture(texture_id_);
 
   if (manager_)
     manager_->UnregisterMediaPlayer(player_id_);
 
   if (main_loop_)
     main_loop_->RemoveDestructionObserver(this);
 }
@@ skipping 204 matching lines @@
   return 0;
 }
 
 void WebMediaPlayerAndroid::OnMediaPrepared(base::TimeDelta duration) {
   if (url_.SchemeIs("file"))
     UpdateNetworkState(WebMediaPlayer::NetworkStateLoaded);
 
   if (ready_state_ != WebMediaPlayer::ReadyStateHaveEnoughData) {
     UpdateReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
     UpdateReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
-#ifndef REMOVE_WEBVIDEOFRAME
-  } else {
-    // If the status is already set to ReadyStateHaveEnoughData, set it again
-    // to make sure that Videolayerchromium will get created.
-    UpdateReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
-#endif
   }
 
-#ifdef REMOVE_WEBVIDEOFRAME
   if (hasVideo() && !video_weblayer_ && client_->needsWebLayerForVideo()) {
     video_weblayer_.reset(
         new webkit::WebLayerImpl(cc::VideoLayer::Create(this)));
     client_->setWebLayer(video_weblayer_.get());
   }
-#endif
 
   // In we have skipped loading, we have to update webkit about the new
   // duration.
   if (duration_ != duration) {
     duration_ = duration;
     client_->durationChanged();
   }
 }
 
 void WebMediaPlayerAndroid::OnPlaybackComplete() {
@@ skipping 117 matching lines @@
 #endif
   } else if (texture_id_) {
     current_frame_ = VideoFrame::WrapNativeTexture(
         texture_id_, kGLTextureExternalOES, natural_size_,
         gfx::Rect(natural_size_), natural_size_, base::TimeDelta(),
         VideoFrame::ReadPixelsCB(),
         base::Closure());
   }
 }
 
-#ifndef REMOVE_WEBVIDEOFRAME
-WebVideoFrame* WebMediaPlayerAndroid::getCurrentFrame() {
-  if (stream_texture_proxy_ && !stream_texture_proxy_->IsInitialized() &&
-      stream_id_ && !needs_external_surface_) {
-    gfx::Size natural_size = current_frame_->natural_size();
-    stream_texture_proxy_->Initialize(
-        stream_id_, natural_size.width(), natural_size.height());
-  }
-
-  return new WebVideoFrameImpl(current_frame_);
-}
-
-void WebMediaPlayerAndroid::putCurrentFrame(
-    WebVideoFrame* web_video_frame) {
-  delete web_video_frame;
-}
-
-void WebMediaPlayerAndroid::setStreamTextureClient(
-    WebKit::WebStreamTextureClient* client) {
-  if (stream_texture_proxy_.get())
-    stream_texture_proxy_->SetClient(client);
-}
-#else
 void WebMediaPlayerAndroid::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;
 
   // Set the callback target when a frame is produced.
   if (stream_texture_proxy_)
     stream_texture_proxy_->SetClient(client);
 }
 
 scoped_refptr<media::VideoFrame> WebMediaPlayerAndroid::GetCurrentFrame() {
   if (stream_texture_proxy_ && !stream_texture_proxy_->IsInitialized() &&
       stream_id_ && !needs_external_surface_) {
     gfx::Size natural_size = current_frame_->natural_size();
     stream_texture_proxy_->Initialize(
         stream_id_, natural_size.width(), natural_size.height());
   }
   return current_frame_;
 }
 
 void WebMediaPlayerAndroid::PutCurrentFrame(
     const scoped_refptr<media::VideoFrame>& frame) {
 }
-#endif
 
 void WebMediaPlayerAndroid::EstablishSurfaceTexturePeer() {
   if (stream_texture_factory_.get() && stream_id_)
     stream_texture_factory_->EstablishPeer(stream_id_, player_id_);
   needs_establish_peer_ = false;
 }
 
 void WebMediaPlayerAndroid::SetNeedsEstablishPeer(bool needs_establish_peer) {
   needs_establish_peer_ = needs_establish_peer;
 }
 
 void WebMediaPlayerAndroid::UpdatePlayingState(bool is_playing) {
   is_playing_ = is_playing;
 }
 
 }  // namespace webkit_media