Remove Chrome for TV code.

content/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 "content/renderer/media/android/webmediaplayer_android.h"
 
 #include <limits>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 22 matching lines @@
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "ui/gfx/image/image.h"
 #include "webkit/renderer/compositor_bindings/web_layer_impl.h"
 
-#if defined(GOOGLE_TV)
-#include "content/renderer/media/media_stream_audio_renderer.h"
-#include "content/renderer/media/media_stream_client.h"
-#endif
-
 static const uint32 kGLTextureExternalOES = 0x8D65;
 
 using blink::WebMediaPlayer;
 using blink::WebSize;
 using blink::WebString;
 using blink::WebTimeRanges;
 using blink::WebURL;
 using media::MediaPlayerAndroid;
 using media::VideoFrame;
 
@@ skipping 44 matching lines @@
       is_playing_(false),
       playing_started_(false),
       needs_establish_peer_(true),
       stream_texture_proxy_initialized_(false),
       has_size_info_(false),
       has_media_metadata_(false),
       has_media_info_(false),
       stream_texture_factory_(factory),
       needs_external_surface_(false),
       video_frame_provider_client_(NULL),
-#if defined(GOOGLE_TV)
-      external_surface_threshold_(-1),
-      demuxer_(NULL),
-      media_stream_client_(NULL),
-#endif  // defined(GOOGLE_TV)
       pending_playback_(false),
       player_type_(MEDIA_PLAYER_TYPE_URL),
       current_time_(0),
       is_remote_(false),
       media_log_(media_log),
       weak_factory_(this) {
   DCHECK(manager_);
 
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   // We want to be notified of |main_loop_| destruction.
   base::MessageLoop::current()->AddDestructionObserver(this);
 
   player_id_ = manager_->RegisterMediaPlayer(this);
 
-#if defined(GOOGLE_TV)
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kUseExternalVideoSurfaceThresholdInPixels)) {
-    if (!base::StringToInt(
-        CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
-            switches::kUseExternalVideoSurfaceThresholdInPixels),
-        &external_surface_threshold_)) {
-      external_surface_threshold_ = -1;
-    }
-  }
-#endif  // defined(GOOGLE_TV)
-
 #if defined(VIDEO_HOLE)
   // Defer stream texture creation until we are sure it's necessary.
   needs_establish_peer_ = false;
   current_frame_ = VideoFrame::CreateBlackFrame(gfx::Size(1, 1));
 #endif  // defined(VIDEO_HOLE)
   TryCreateStreamTextureProxyIfNeeded();
 
   if (blink::WebRuntimeFeatures::isPrefixedEncryptedMediaEnabled()) {
     // TODO(xhwang): Report an error when there is encrypted stream but EME is
     // not enabled. Currently the player just doesn't start and waits for ever.
@@ skipping 31 matching lines @@
         stream_texture_factory_->Context3d();
     if (context->makeContextCurrent())
       context->deleteTexture(remote_playback_texture_id_);
   }
 
   if (base::MessageLoop::current())
     base::MessageLoop::current()->RemoveDestructionObserver(this);
 
   if (player_type_ == MEDIA_PLAYER_TYPE_MEDIA_SOURCE && delegate_)
     delegate_->PlayerGone(this);
-
-#if defined(GOOGLE_TV)
-  if (audio_renderer_) {
-    if (audio_renderer_->IsLocalRenderer()) {
-      audio_renderer_->Stop();
-    } else if (!paused()) {
-      // The |audio_renderer_| can be shared by multiple remote streams, and
-      // it will be stopped when WebRtcAudioDeviceImpl goes away. So we simply
-      // pause the |audio_renderer_| here to avoid re-creating the
-      // |audio_renderer_|.
-      audio_renderer_->Pause();
-    }
-  }
-  if (demuxer_ && !destroy_demuxer_cb_.is_null()) {
-    media_source_delegate_.reset();
-    destroy_demuxer_cb_.Run();
-  }
-#endif
 }
 
 void WebMediaPlayerAndroid::load(LoadType load_type,
                                  const blink::WebURL& url,
                                  CORSMode cors_mode) {
   switch (load_type) {
     case LoadTypeURL:
       player_type_ = MEDIA_PLAYER_TYPE_URL;
       break;
 
     case LoadTypeMediaSource:
       player_type_ = MEDIA_PLAYER_TYPE_MEDIA_SOURCE;
       break;
 
     case LoadTypeMediaStream:
-#if defined(GOOGLE_TV)
-      player_type_ = MEDIA_PLAYER_TYPE_MEDIA_STREAM;
-      break;
-#else
       CHECK(false) << "WebMediaPlayerAndroid doesn't support MediaStream on "
                       "this platform";
       return;
-#endif
   }
 
   has_media_metadata_ = false;
   has_media_info_ = false;
 
   media::SetDecryptorReadyCB set_decryptor_ready_cb;
   if (decryptor_) {  // |decryptor_| can be NULL is EME if not enabled.
     set_decryptor_ready_cb = base::Bind(&ProxyDecryptor::SetDecryptorReadyCB,
                                         base::Unretained(decryptor_.get()));
   }
@@ skipping 14 matching lines @@
       media_source_delegate_->InitializeMediaSource(
           base::Bind(&WebMediaPlayerAndroid::OnMediaSourceOpened,
                      weak_factory_.GetWeakPtr()),
           base::Bind(&WebMediaPlayerAndroid::OnNeedKey, base::Unretained(this)),
           set_decryptor_ready_cb,
           base::Bind(&WebMediaPlayerAndroid::UpdateNetworkState,
                      weak_factory_.GetWeakPtr()),
           base::Bind(&WebMediaPlayerAndroid::OnDurationChanged,
                      weak_factory_.GetWeakPtr()));
     }
-#if defined(GOOGLE_TV)
-    // TODO(xhwang): Pass set_decryptor_ready_cb in InitializeMediaStream() to
-    // enable ClearKey support for Google TV.
-    if (player_type_ == MEDIA_PLAYER_TYPE_MEDIA_STREAM) {
-      media_source_delegate_->InitializeMediaStream(
-          demuxer_,
-          base::Bind(&WebMediaPlayerAndroid::UpdateNetworkState,
-                     weak_factory_.GetWeakPtr()));
-      audio_renderer_ = media_stream_client_->GetAudioRenderer(url);
-      if (audio_renderer_)
-        audio_renderer_->Start();
-    }
-#endif
   } else {
     info_loader_.reset(
         new MediaInfoLoader(
             url,
             cors_mode,
             base::Bind(&WebMediaPlayerAndroid::DidLoadMediaInfo,
                        base::Unretained(this))));
     info_loader_->Start(frame_);
   }
 
@@ skipping 32 matching lines @@
 }
 
 void WebMediaPlayerAndroid::play() {
 #if defined(VIDEO_HOLE)
   if (hasVideo() && needs_external_surface_ &&
       !manager_->IsInFullscreen(frame_)) {
     DCHECK(!needs_establish_peer_);
     manager_->RequestExternalSurface(player_id_, last_computed_rect_);
   }
 #endif  // defined(VIDEO_HOLE)
-#if defined(GOOGLE_TV)
-  if (audio_renderer_ && paused())
-    audio_renderer_->Play();
-#endif  // defined(GOOGLE_TV)
 
   TryCreateStreamTextureProxyIfNeeded();
   if (hasVideo() && needs_establish_peer_)
     EstablishSurfaceTexturePeer();
 
   if (paused())
     manager_->Start(player_id_);
   UpdatePlayingState(true);
   UpdateNetworkState(WebMediaPlayer::NetworkStateLoading);
   playing_started_ = true;
@@ skipping 375 matching lines @@
   }
   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(VIDEO_HOLE)
-  bool has_surface_size_restriction = false;
-#if defined(GOOGLE_TV)
-  has_surface_size_restriction = external_surface_threshold_ >= 0 &&
-       external_surface_threshold_ <= width * height;
-#endif  // defined(GOOGLE_TV)
   // Use H/W surface for MSE as the content might be protected.
   // TODO(qinmin): Change this so that only EME needs the H/W surface
-  if (media_source_delegate_ || has_surface_size_restriction) {
+  if (media_source_delegate_) {
     needs_external_surface_ = true;
     if (!paused() && !manager_->IsInFullscreen(frame_))
       manager_->RequestExternalSurface(player_id_, last_computed_rect_);
   } else if (stream_texture_factory_ && !stream_id_) {
     // Do deferred stream texture creation finally.
     DoCreateStreamTexture();
     if (paused()) {
       SetNeedsEstablishPeer(true);
     } else {
       EstablishSurfaceTexturePeer();
@@ skipping 158 matching lines @@
   media_source_delegate_.reset();
   {
     base::AutoLock auto_lock(current_frame_lock_);
     current_frame_ = NULL;
   }
   is_remote_ = false;
   manager_ = NULL;
 }
 
 void WebMediaPlayerAndroid::Pause(bool is_media_related_action) {
-#if defined(GOOGLE_TV)
-  if (audio_renderer_ && !paused())
-    audio_renderer_->Pause();
-#endif
   manager_->Pause(player_id_, is_media_related_action);
   UpdatePlayingState(false);
 }
 
 void WebMediaPlayerAndroid::DrawRemotePlaybackIcon() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (!video_weblayer_)
     return;
   blink::WebGraphicsContext3D* context = stream_texture_factory_->Context3d();
   if (!context->makeContextCurrent())
@@ skipping 423 matching lines @@
   if (current_key_system_.isEmpty() || key_system != current_key_system_)
     return WebMediaPlayer::MediaKeyExceptionInvalidPlayerState;
 
   decryptor_->CancelKeyRequest(session_id.utf8());
   return WebMediaPlayer::MediaKeyExceptionNoError;
 }
 
 void WebMediaPlayerAndroid::OnKeyAdded(const std::string& session_id) {
   EmeUMAHistogramCounts(current_key_system_, "KeyAdded", 1);
 
-#if defined(GOOGLE_TV)
-  if (media_source_delegate_)
-    media_source_delegate_->NotifyKeyAdded(current_key_system_.utf8());
-#endif  // defined(GOOGLE_TV)
-
   client_->keyAdded(current_key_system_, WebString::fromUTF8(session_id));
 }
 
 void WebMediaPlayerAndroid::OnKeyError(const std::string& session_id,
                                        media::MediaKeys::KeyError error_code,
                                        int system_code) {
   EmeUMAHistogramEnumeration(current_key_system_, "KeyError",
                              error_code, media::MediaKeys::kMaxKeyError);
 
   client_->keyError(
@@ skipping 38 matching lines @@
     init_data_type_ = type;
 
   const uint8* init_data_ptr = init_data.empty() ? NULL : &init_data[0];
   // TODO(xhwang): Drop |keySystem| and |sessionId| in keyNeeded() call.
   client_->keyNeeded(WebString(),
                      WebString(),
                      init_data_ptr,
                      init_data.size());
 }
 
-#if defined(GOOGLE_TV)
-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
-
 void WebMediaPlayerAndroid::DoReleaseRemotePlaybackTexture(uint32 sync_point) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(remote_playback_texture_id_);
 
   blink::WebGraphicsContext3D* context =
       stream_texture_factory_->Context3d();
 
   if (sync_point)
     context->waitSyncPoint(sync_point);
   context->deleteTexture(remote_playback_texture_id_);
   remote_playback_texture_id_ = 0;
 }
 
 void WebMediaPlayerAndroid::enterFullscreen() {
   if (manager_->CanEnterFullscreen(frame_)) {
     manager_->EnterFullscreen(player_id_);
     SetNeedsEstablishPeer(false);
   }
 }
 
 void WebMediaPlayerAndroid::exitFullscreen() {
   manager_->ExitFullscreen(player_id_);
 }
 
 bool WebMediaPlayerAndroid::canEnterFullscreen() const {
   return manager_->CanEnterFullscreen(frame_);
 }
 
 }  // namespace content