Implement WebRTC in Chrome for TV

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 "base/strings/string_number_conversions.h"
 #include "cc/layers/video_layer.h"
 #include "gpu/GLES2/gl2extchromium.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/Platform/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.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/WebMediaSource.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "webkit/compositor_bindings/web_layer_impl.h"
 #include "webkit/media/android/webmediaplayer_manager_android.h"
 #include "webkit/media/android/webmediaplayer_proxy_android.h"
 #include "webkit/media/media_switches.h"
 #include "webkit/media/webmediaplayer_util.h"
 
-#if defined(GOOGLE_TV)
-#include "webkit/media/android/media_source_delegate.h"
-#endif
-
 static const uint32 kGLTextureExternalOES = 0x8D65;
 
 using WebKit::WebMediaPlayer;
 using WebKit::WebMediaSource;
 using WebKit::WebSize;
 using WebKit::WebString;
 using WebKit::WebTimeRanges;
 using WebKit::WebURL;
 using media::MediaPlayerBridge;
 using media::VideoFrame;
 
 namespace webkit_media {
 
 WebMediaPlayerAndroid::WebMediaPlayerAndroid(
     WebKit::WebFrame* frame,
     WebKit::WebMediaPlayerClient* client,
     WebMediaPlayerManagerAndroid* manager,
     WebMediaPlayerProxyAndroid* proxy,
-    StreamTextureFactory* factory,
-    media::MediaLog* media_log)
+    StreamTextureFactory* factory)
     : frame_(frame),
       client_(client),
       buffered_(1u),
       main_loop_(base::MessageLoop::current()),
       pending_seek_(0),
       seeking_(false),
       did_loading_progress_(false),
       manager_(manager),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       is_playing_(false),
       needs_establish_peer_(true),
       has_size_info_(false),
       stream_texture_factory_(factory),
       needs_external_surface_(false),
       video_frame_provider_client_(NULL),
       proxy_(proxy),
-      current_time_(0),
-      media_log_(media_log) {
+      current_time_(0) {
   main_loop_->AddDestructionObserver(this);
   if (manager_)
     player_id_ = manager_->RegisterMediaPlayer(this);
 
   if (stream_texture_factory_.get()) {
     stream_texture_proxy_.reset(stream_texture_factory_->CreateProxy());
     stream_id_ = stream_texture_factory_->CreateStreamTexture(&texture_id_);
     ReallocateVideoFrame();
   }
 }
@@ skipping 19 matching lines @@
   load(url, NULL, cors_mode);
 }
 
 void WebMediaPlayerAndroid::load(const WebURL& url,
                                  WebMediaSource* media_source,
                                  CORSMode cors_mode) {
   if (cors_mode != CORSModeUnspecified)
     NOTIMPLEMENTED() << "No CORS support";
 
   scoped_ptr<WebKit::WebMediaSource> scoped_media_source(media_source);
-#if defined(GOOGLE_TV)
-  if (media_source) {
-    media_source_delegate_.reset(
-        new MediaSourceDelegate(
-            frame_, client_, proxy_, player_id_, media_log_));
-    // |media_source_delegate_| is owned, so Unretained() is safe here.
-    media_source_delegate_->Initialize(
-        scoped_media_source.Pass(),
-        base::Bind(&WebMediaPlayerAndroid::UpdateNetworkState,
-                   base::Unretained(this)));
-  }
-#endif
 
+  InitializeMediaPlayer(
+      url, media_source == NULL ? 0 : MediaPlayerBridge::FLAG_MEDIA_SOURCE);
+}
+
+void WebMediaPlayerAndroid::InitializeMediaPlayer(const WebURL& url,
+                                                  int flags) {
   url_ = url;
   GURL first_party_url = frame_->document().firstPartyForCookies();
   if (proxy_) {
-    proxy_->Initialize(player_id_, url_, media_source != NULL, first_party_url);
+    proxy_->Initialize(player_id_, url, flags, first_party_url);
     if (manager_->IsInFullscreen(frame_))
       proxy_->EnterFullscreen(player_id_);
   }
 
   UpdateNetworkState(WebMediaPlayer::NetworkStateLoading);
   UpdateReadyState(WebMediaPlayer::ReadyStateHaveNothing);
 }
 
 void WebMediaPlayerAndroid::cancelLoad() {
   NOTIMPLEMENTED();
 }
 
 void WebMediaPlayerAndroid::play() {
-#if defined(GOOGLE_TV)
-  if (hasVideo() && needs_external_surface_) {
-    DCHECK(!needs_establish_peer_);
-    if (proxy_)
-      proxy_->RequestExternalSurface(player_id_);
-  }
-#endif
   if (hasVideo() && needs_establish_peer_)
     EstablishSurfaceTexturePeer();
 
   if (paused() && proxy_)
     proxy_->Start(player_id_);
   is_playing_ = true;
 }
 
 void WebMediaPlayerAndroid::pause() {
   if (proxy_)
     proxy_->Pause(player_id_);
   is_playing_ = false;
 }
 
 void WebMediaPlayerAndroid::seek(double seconds) {
   pending_seek_ = seconds;
   seeking_ = true;
 
   base::TimeDelta seek_time = ConvertSecondsToTimestamp(seconds);
-#if defined(GOOGLE_TV)
-  if (media_source_delegate_)
-    media_source_delegate_->Seek(seek_time);
-#endif
   if (proxy_)
     proxy_->Seek(player_id_, seek_time);
 }
 
 bool WebMediaPlayerAndroid::supportsFullscreen() const {
   return true;
 }
 
 bool WebMediaPlayerAndroid::supportsSave() const {
   return false;
@@ skipping 75 matching lines @@
 
 WebMediaPlayer::NetworkState WebMediaPlayerAndroid::networkState() const {
   return network_state_;
 }
 
 WebMediaPlayer::ReadyState WebMediaPlayerAndroid::readyState() const {
   return ready_state_;
 }
 
 const WebTimeRanges& WebMediaPlayerAndroid::buffered() {
-#if defined(GOOGLE_TV)
-  if (media_source_delegate_)
-    return media_source_delegate_->Buffered();
-#endif
   return buffered_;
 }
 
 double WebMediaPlayerAndroid::maxTimeSeekable() const {
   // TODO(hclam): If this stream is not seekable this should return 0.
   return duration();
 }
 
 bool WebMediaPlayerAndroid::didLoadingProgress() const {
   bool ret = did_loading_progress_;
@@ skipping 60 matching lines @@
   // Deprecated.
   // TODO(qinmin): Remove this from WebKit::WebMediaPlayer as it is never used.
   return WebMediaPlayer::MovieLoadTypeUnknown;
 }
 
 double WebMediaPlayerAndroid::mediaTimeForTimeValue(double timeValue) const {
   return ConvertSecondsToTimestamp(timeValue).InSecondsF();
 }
 
 unsigned WebMediaPlayerAndroid::decodedFrameCount() const {
-#if defined(GOOGLE_TV)
-  if (media_source_delegate_)
-    return media_source_delegate_->DecodedFrameCount();
-#endif
   NOTIMPLEMENTED();
   return 0;
 }
 
 unsigned WebMediaPlayerAndroid::droppedFrameCount() const {
-#if defined(GOOGLE_TV)
-  if (media_source_delegate_)
-    return media_source_delegate_->DroppedFrameCount();
-#endif
   NOTIMPLEMENTED();
   return 0;
 }
 
 unsigned WebMediaPlayerAndroid::audioDecodedByteCount() const {
-#if defined(GOOGLE_TV)
-  if (media_source_delegate_)
-    return media_source_delegate_->AudioDecodedByteCount();
-#endif
   NOTIMPLEMENTED();
   return 0;
 }
 
 unsigned WebMediaPlayerAndroid::videoDecodedByteCount() const {
-#if defined(GOOGLE_TV)
-  if (media_source_delegate_)
-    return media_source_delegate_->VideoDecodedByteCount();
-#endif
   NOTIMPLEMENTED();
   return 0;
 }
 
 void WebMediaPlayerAndroid::OnMediaMetadataChanged(
     base::TimeDelta duration, int width, int height, bool success) {
   if (url_.SchemeIs("file"))
     UpdateNetworkState(WebMediaPlayer::NetworkStateLoaded);
 
   if (ready_state_ != WebMediaPlayer::ReadyStateHaveEnoughData) {
@@ skipping 57 matching lines @@
       break;
   }
   client_->repaint();
 }
 
 void WebMediaPlayerAndroid::OnVideoSizeChanged(int width, int height) {
   has_size_info_ = true;
   if (natural_size_.width == width && natural_size_.height == height)
     return;
 
-#if defined(GOOGLE_TV)
-  static bool has_switch = CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kUseExternalVideoSurfaceThresholdInPixels);
-  static int threshold = 0;
-  static bool parsed_arg =
-      has_switch &&
-      base::StringToInt(
-          CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-              switches::kUseExternalVideoSurfaceThresholdInPixels),
-          &threshold);
-
-  if ((parsed_arg && threshold <= width * height) ||
-      // Use H/W surface for MSE as the content is protected.
-      media_source_delegate_) {
-    needs_external_surface_ = true;
-    SetNeedsEstablishPeer(false);
-    if (!paused() && proxy_)
-      proxy_->RequestExternalSurface(player_id_);
-  }
-#endif
-
   natural_size_.width = width;
   natural_size_.height = height;
   ReallocateVideoFrame();
 }
 
 void WebMediaPlayerAndroid::OnTimeUpdate(base::TimeDelta current_time) {
   current_time_ = static_cast<float>(current_time.InSecondsF());
 }
 
 void WebMediaPlayerAndroid::OnDidEnterFullscreen() {
@@ skipping 79 matching lines @@
     stream_texture_factory_->DestroyStreamTexture(texture_id_);
     stream_id_ = 0;
   }
 
   current_frame_ = NULL;
   manager_ = NULL;
   proxy_ = NULL;
 }
 
 void WebMediaPlayerAndroid::ReallocateVideoFrame() {
-  if (needs_external_surface_) {
+  if (NeedsExternalSurface()) {
     // VideoFrame::CreateHoleFrame is only defined under GOOGLE_TV.
 #if defined(GOOGLE_TV)
     if (!natural_size_.isEmpty())
       current_frame_ = VideoFrame::CreateHoleFrame(natural_size_);
 #else
     NOTIMPLEMENTED() << "Hole punching not supported outside of Google TV";
 #endif
   } else if (texture_id_) {
     current_frame_ = VideoFrame::WrapNativeTexture(
         texture_id_, kGLTextureExternalOES, natural_size_,
@@ skipping 11 matching lines @@
     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_->IsBoundToThread() &&
-      stream_id_ && !needs_external_surface_) {
+      stream_id_ && !NeedsExternalSurface()) {
     gfx::Size natural_size = current_frame_->natural_size();
     stream_texture_proxy_->BindToCurrentThread(
         stream_id_, natural_size.width(), natural_size.height());
   }
   return current_frame_;
 }
 
 void WebMediaPlayerAndroid::PutCurrentFrame(
     const scoped_refptr<media::VideoFrame>& frame) {
 }
@@ skipping 26 matching lines @@
   }
 
   // Return false when the geometry hasn't been changed from the last time.
   if (last_computed_rect_ == *rect)
     return false;
 
   // Store the changed geometry information when it is actually changed.
   last_computed_rect_ = *rect;
   return true;
 }
-
-WebMediaPlayer::MediaKeyException
-WebMediaPlayerAndroid::generateKeyRequest(const WebString& key_system,
-                                              const unsigned char* init_data,
-                                              unsigned init_data_length) {
-  if (media_source_delegate_) {
-    return media_source_delegate_->GenerateKeyRequest(
-        key_system, init_data, init_data_length);
-  }
-  return MediaKeyExceptionKeySystemNotSupported;
-}
-
-WebMediaPlayer::MediaKeyException WebMediaPlayerAndroid::addKey(
-    const WebString& key_system,
-    const unsigned char* key,
-    unsigned key_length,
-    const unsigned char* init_data,
-    unsigned init_data_length,
-    const WebString& session_id) {
-  if (media_source_delegate_) {
-    return media_source_delegate_->AddKey(
-        key_system, key, key_length, init_data, init_data_length, session_id);
-  }
-  return MediaKeyExceptionKeySystemNotSupported;
-}
-
-WebMediaPlayer::MediaKeyException WebMediaPlayerAndroid::cancelKeyRequest(
-    const WebString& key_system,
-    const WebString& session_id) {
-  if (media_source_delegate_)
-    return media_source_delegate_->CancelKeyRequest(key_system, session_id);
-  return MediaKeyExceptionKeySystemNotSupported;
-}
-
-void WebMediaPlayerAndroid::OnReadFromDemuxer(
-    media::DemuxerStream::Type type, bool seek_done) {
-  if (media_source_delegate_)
-    media_source_delegate_->OnReadFromDemuxer(type, seek_done);
-  else
-    NOTIMPLEMENTED();
-}
 #endif
 
 void WebMediaPlayerAndroid::enterFullscreen() {
   if (proxy_ && manager_->CanEnterFullscreen(frame_)) {
     proxy_->EnterFullscreen(player_id_);
     SetNeedsEstablishPeer(false);
   }
 }
 
 void WebMediaPlayerAndroid::exitFullscreen() {
   if (proxy_)
     proxy_->ExitFullscreen(player_id_);
 }
 
 bool WebMediaPlayerAndroid::canEnterFullscreen() const {
   return manager_->CanEnterFullscreen(frame_);
 }
 
+bool WebMediaPlayerAndroid::NeedsExternalSurface() {
+  return needs_external_surface_;
+}
+
+void WebMediaPlayerAndroid::SetNeedsExternalSurface(
+    bool needs_external_surface) {
+  needs_external_surface_ = needs_external_surface;
+}
+
+WebMediaPlayerProxyAndroid* WebMediaPlayerAndroid::proxy() { return proxy_; }

[qinmin, 2013/04/29 17:31:49]

move these functions to the header

[wonsik, 2013/05/01 14:15:38]

Done.

+WebKit::WebFrame* WebMediaPlayerAndroid::frame() { return frame_; }
+WebKit::WebMediaPlayerClient* WebMediaPlayerAndroid::client() {
+  return client_;
+}
+int WebMediaPlayerAndroid::player_id() { return player_id_; }
+
 }  // namespace webkit_media