Implement WebRTC in Chrome for TV

webkit/renderer/media/android/webmediaplayer_android.cc

 // Copyright 2013 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/renderer/media/android/webmediaplayer_android.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
@@ skipping 11 matching lines @@
 #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/WebRuntimeFeatures.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "webkit/renderer/compositor_bindings/web_layer_impl.h"
 #include "webkit/renderer/media/android/webmediaplayer_manager_android.h"
 #include "webkit/renderer/media/android/webmediaplayer_proxy_android.h"
 #include "webkit/renderer/media/crypto/key_systems.h"
 #include "webkit/renderer/media/webmediaplayer_util.h"
 
+#if defined(GOOGLE_TV)
+#include "webkit/renderer/media/media_stream_audio_renderer.h"
+#include "webkit/renderer/media/media_stream_client.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::MediaPlayerAndroid;
 using media::VideoFrame;
@@ skipping 24 matching lines @@
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       is_playing_(false),
       needs_establish_peer_(true),
       stream_texture_proxy_initialized_(false),
       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) {
+      media_log_(media_log),
+      media_stream_client_(NULL) {
   main_loop_->AddDestructionObserver(this);
   if (manager_)
     player_id_ = manager_->RegisterMediaPlayer(this);
 
   if (stream_texture_factory_) {
     stream_texture_proxy_.reset(stream_texture_factory_->CreateProxy());
     stream_id_ = stream_texture_factory_->CreateStreamTexture(&texture_id_);
     ReallocateVideoFrame();
   }
 
 #if defined(GOOGLE_TV)
   if (WebKit::WebRuntimeFeatures::isLegacyEncryptedMediaEnabled()) {
     // |decryptor_| is owned, so Unretained() is safe here.
     decryptor_.reset(new ProxyDecryptor(
         client,
         frame,
         base::Bind(&WebMediaPlayerAndroid::OnKeyAdded, base::Unretained(this)),
         base::Bind(&WebMediaPlayerAndroid::OnKeyError, base::Unretained(this)),
         base::Bind(&WebMediaPlayerAndroid::OnKeyMessage,
                    base::Unretained(this)),
         base::Bind(&WebMediaPlayerAndroid::OnNeedKey, base::Unretained(this))));
   }
+
+  demuxer_ = NULL;
 #endif  // defined(GOOGLE_TV)
 }
 
 WebMediaPlayerAndroid::~WebMediaPlayerAndroid() {
   SetVideoFrameProviderClient(NULL);
   client_->setWebLayer(NULL);
 
   if (proxy_)
     proxy_->DestroyPlayer(player_id_);
 
   if (stream_id_)
     stream_texture_factory_->DestroyStreamTexture(texture_id_);
 
   if (manager_)
     manager_->UnregisterMediaPlayer(player_id_);
 
   if (main_loop_)
     main_loop_->RemoveDestructionObserver(this);
+#if defined(GOOGLE_TV)
+  if (demuxer_ && !destroy_demuxer_cb_.is_null()) {
+    media_source_delegate_.reset();
+    destroy_demuxer_cb_.Run();
+  }
+#endif
 }
 
 void WebMediaPlayerAndroid::load(const WebURL& url, CORSMode cors_mode) {
   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";
 
-  if (media_source) {
+  MediaPlayerAndroid::SourceType source_type =
+      MediaPlayerAndroid::SOURCE_TYPE_URL;
+
+  if (media_source)
+    source_type = MediaPlayerAndroid::SOURCE_TYPE_MSE;
+#if defined(GOOGLE_TV)
+  if (media_stream_client_) {
+    DCHECK(!media_source);
+    source_type = MediaPlayerAndroid::SOURCE_TYPE_STREAM;
+  }
+#endif
+
+  if (source_type != MediaPlayerAndroid::SOURCE_TYPE_URL) {
     media_source_delegate_.reset(
         new MediaSourceDelegate(proxy_, player_id_, media_log_));
     // |media_source_delegate_| is owned, so Unretained() is safe here.
-    media_source_delegate_->Initialize(
-        media_source,
-        base::Bind(&WebMediaPlayerAndroid::OnNeedKey, base::Unretained(this)),
-        base::Bind(&WebMediaPlayerAndroid::UpdateNetworkState,
-                   base::Unretained(this)));
+    if (source_type == MediaPlayerAndroid::SOURCE_TYPE_MSE) {
+      media_source_delegate_->InitializeMediaSource(
+          media_source,
+          base::Bind(&WebMediaPlayerAndroid::OnNeedKey, base::Unretained(this)),
+          base::Bind(&WebMediaPlayerAndroid::UpdateNetworkState,
+                     base::Unretained(this)));
+    }
+#if defined(GOOGLE_TV)
+    if (source_type == MediaPlayerAndroid::SOURCE_TYPE_STREAM) {
+      media_source_delegate_->InitializeMediaStream(
+          demuxer_,
+          base::Bind(&WebMediaPlayerAndroid::UpdateNetworkState,
+                     base::Unretained(this)));
+    }
+#endif
   }
 
+  InitializeMediaPlayer(url, source_type);
+}
+
+void WebMediaPlayerAndroid::InitializeMediaPlayer(
+    const WebURL& url,
+    MediaPlayerAndroid::SourceType source_type) {
   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, source_type, first_party_url);
     if (manager_->IsInFullscreen(frame_))
       proxy_->EnterFullscreen(player_id_);
   }
 
   UpdateNetworkState(WebMediaPlayer::NetworkStateLoading);
   UpdateReadyState(WebMediaPlayer::ReadyStateHaveNothing);
 }
 
 void WebMediaPlayerAndroid::cancelLoad() {
   NOTIMPLEMENTED();
@@ skipping 758 matching lines @@
   const GURL default_url_gurl(default_url);
   DLOG_IF(WARNING, !default_url.empty() && !default_url_gurl.is_valid())
       << "Invalid URL in default_url: " << default_url;
 
   client_->keyMessage(WebString::fromUTF8(key_system),
                       WebString::fromUTF8(session_id),
                       reinterpret_cast<const uint8*>(message.data()),
                       message.size(),
                       default_url_gurl);
 }
+
+bool WebMediaPlayerAndroid::InjectMediaStream(
+    MediaStreamClient* media_stream_client,
+    media::Demuxer* demuxer,
+    const base::Closure& destroy_demuxer_cb) {
+  DCHECK(!demuxer);
+  media_stream_client_ = media_stream_client;
+  demuxer_ = demuxer;
+  destroy_demuxer_cb_ = destroy_demuxer_cb;
+  return true;
+}
 #endif  // defined(GOOGLE_TV)
 
 void WebMediaPlayerAndroid::OnNeedKey(const std::string& key_system,
                                       const std::string& session_id,
                                       const std::string& type,
                                       scoped_ptr<uint8[]> init_data,
                                       int init_data_size) {
   // Do not fire NeedKey event if encrypted media is not enabled.
   if (!decryptor_)
     return;
@@ skipping 28 matching lines @@
 void WebMediaPlayerAndroid::exitFullscreen() {
   if (proxy_)
     proxy_->ExitFullscreen(player_id_);
 }
 
 bool WebMediaPlayerAndroid::canEnterFullscreen() const {
   return manager_->CanEnterFullscreen(frame_);
 }
 
 }  // namespace webkit_media