Support CAST+WMPI on android

media/blink/webmediaplayer_impl.cc

Index: media/blink/webmediaplayer_impl.cc
diff --git a/media/blink/webmediaplayer_impl.cc b/media/blink/webmediaplayer_impl.cc
index 5dd65d08719b7a279d88dca947fdb3f0d3ec82f9..3173ace7cd55c5cc1abf38f93d18b64cacd294fe 100644
--- a/media/blink/webmediaplayer_impl.cc
+++ b/media/blink/webmediaplayer_impl.cc
@@ -59,11 +59,25 @@
 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/web/WebView.h"
 
+#if defined(OS_ANDROID)  // WMPI_CAST
+#include "gpu/GLES2/gl2extchromium.h"
+#include "gpu/command_buffer/client/gles2_interface.h"
+#include "media/base/android/media_common_android.h"
+#include "third_party/skia/include/core/SkCanvas.h"
+#include "third_party/skia/include/core/SkPaint.h"
+#include "third_party/skia/include/core/SkTypeface.h"
+#include "third_party/skia/include/gpu/GrContext.h"
+#include "third_party/skia/include/gpu/SkGrPixelRef.h"
+#endif
+
 using blink::WebCanvas;
 using blink::WebMediaPlayer;
 using blink::WebRect;
 using blink::WebSize;
 using blink::WebString;
+using gpu::gles2::GLES2Interface;
+
+namespace media {
 
 namespace {
 
@@ -86,22 +100,39 @@ namespace {
 const double kMinRate = 0.0625;
 const double kMaxRate = 16.0;
 
-void SetSinkIdOnMediaThread(
-    scoped_refptr<media::WebAudioSourceProviderImpl> sink,
-    const std::string& device_id,
-    const url::Origin& security_origin,
-    const media::SwitchOutputDeviceCB& callback) {
+void SetSinkIdOnMediaThread(scoped_refptr<WebAudioSourceProviderImpl> sink,
+                            const std::string& device_id,
+                            const url::Origin& security_origin,
+                            const SwitchOutputDeviceCB& callback) {
   if (sink->GetOutputDevice()) {
     sink->GetOutputDevice()->SwitchOutputDevice(device_id, security_origin,
                                                 callback);
   } else {
-    callback.Run(media::OUTPUT_DEVICE_STATUS_ERROR_INTERNAL);
+    callback.Run(OUTPUT_DEVICE_STATUS_ERROR_INTERNAL);
   }
 }
 
-}  // namespace
+#if defined(OS_ANDROID)  // WMPI_CAST
+// File-static function is to allow it to run even after WMPA is deleted.

[liberato (no reviews please), 2016/01/12 22:14:57]

/WMPA/WMPI/

[hubbe, 2016/01/12 22:39:25]

Done.

+void OnReleaseTexture(const WebMediaPlayerParams::Context3DCB& context_3d_cb,
+                      GLuint texture_id,
+                      const gpu::SyncToken& sync_token) {
+  Context3D context_3d;
+  if (!context_3d_cb.is_null())
+    context_3d = context_3d_cb.Run();
+  // GPU Process crashed.
+  if (!context_3d.gl)
+    return;
 
-namespace media {
+  GLES2Interface* gl = context_3d.gl;
+  gl->WaitSyncTokenCHROMIUM(sync_token.GetConstData());
+  gl->DeleteTextures(1, &texture_id);
+  // Flush to ensure that the stream texture gets deleted in a timely fashion.

[liberato (no reviews please), 2016/01/12 22:14:58]

/stream//

[hubbe, 2016/01/12 22:39:25]

Done.

+  gl->ShallowFlushCHROMIUM();
+}
+#endif  // OS_ANDROID (WMPI_CAST)
+
+}  // namespace
 
 class BufferedDataSourceHostImpl;
 
@@ -207,6 +238,15 @@ WebMediaPlayerImpl::WebMediaPlayerImpl(
 }
 
 WebMediaPlayerImpl::~WebMediaPlayerImpl() {
+#if defined(OS_ANDROID)  // WMPI_CAST
+  if (player_manager_) {
+    if (is_player_initialized_)
+      player_manager_->DestroyPlayer(player_id_);
+
+    player_manager_->UnregisterMediaPlayer(player_id_);
+  }
+#endif
+
   client_->setWebLayer(NULL);
 
   DCHECK(main_task_runner_->BelongsToCurrentThread());
@@ -300,13 +340,31 @@ void WebMediaPlayerImpl::DoLoad(LoadType load_type,
   data_source_->SetBufferingStrategy(buffering_strategy_);
   data_source_->Initialize(
       base::Bind(&WebMediaPlayerImpl::DataSourceInitialized, AsWeakPtr()));
+
+#if defined(OS_ANDROID)   // WMPI_CAST
+  player_manager_->Initialize(MEDIA_PLAYER_TYPE_URL, player_id_, url,
+                              frame_->document().firstPartyForCookies(), 0,
+                              frame_->document().url(), true);
+
+  is_player_initialized_ = true;
+#endif
 }
 
 void WebMediaPlayerImpl::play() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
+#if defined(OS_ANDROID)  // WMPI_CAST
+  if (is_remote_ && paused_) {
+    player_manager_->Start(player_id_);
+    remote_time_at_ = base::TimeTicks::Now();
+    paused_ = false;
+    return;
+  }
+#endif
+
   paused_ = false;
+
   pipeline_.SetPlaybackRate(playback_rate_);
   if (data_source_)
     data_source_->MediaIsPlaying();
@@ -323,6 +381,14 @@ void WebMediaPlayerImpl::pause() {
 
   const bool was_already_paused = paused_ || playback_rate_ == 0;
   paused_ = true;
+
+#if defined(OS_ANDROID)  // WMPI_CAST
+  if (is_remote_) {
+    player_manager_->Pause(player_id_, true);
+    return;
+  }
+#endif
+
   pipeline_.SetPlaybackRate(0.0);
   UpdatePausedTime();
 
@@ -343,12 +409,20 @@ void WebMediaPlayerImpl::seek(double seconds) {
 
   ended_ = false;
 
+  base::TimeDelta new_seek_time = base::TimeDelta::FromSecondsD(seconds);
+
+#if defined(OS_ANDROID)  // WMPI_CAST
+  if (is_remote_) {
+    should_notify_time_changed_ = true;
+    player_manager_->Seek(player_id_, new_seek_time);
+    return;
+  }
+#endif
+
   ReadyState old_state = ready_state_;
   if (ready_state_ > WebMediaPlayer::ReadyStateHaveMetadata)
     SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
 
-  base::TimeDelta new_seek_time = base::TimeDelta::FromSecondsD(seconds);
-
   if (seeking_ || suspended_) {
     // Once resuming, it's too late to change the resume time and so the
     // implementation is a little different.
@@ -422,7 +496,6 @@ void WebMediaPlayerImpl::seek(double seconds) {
   if (chunk_demuxer_)
     chunk_demuxer_->StartWaitingForSeek(seek_time_);
 
-  // Kick off the asynchronous seek!
   pipeline_.Seek(seek_time_, BIND_TO_RENDER_LOOP1(
                                  &WebMediaPlayerImpl::OnPipelineSeeked, true));
 }
@@ -539,6 +612,10 @@ blink::WebSize WebMediaPlayerImpl::naturalSize() const {
 bool WebMediaPlayerImpl::paused() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
+#if defined(OS_ANDROID)  // WMPI_CAST
+  if (is_remote_)
+    return paused_;
+#endif
   return pipeline_.GetPlaybackRate() == 0.0f;
 }
 
@@ -586,7 +663,21 @@ double WebMediaPlayerImpl::currentTime() const {
                          : seek_time_.InSecondsF();
   }
 
-  return (paused_ ? paused_time_ : pipeline_.GetMediaTime()).InSecondsF();
+#if defined(OS_ANDROID)  // WMPI_CAST
+  if (is_remote_) {
+    base::TimeDelta ret = remote_time_;
+    if (!paused_) {
+      ret += base::TimeTicks::Now() - remote_time_at_;
+    }
+    return ret.InSecondsF();
+  }
+#endif
+
+  if (paused_) {
+    return paused_time_.InSecondsF();
+  }
+
+  return pipeline_.GetMediaTime().InSecondsF();
 }
 
 WebMediaPlayer::NetworkState WebMediaPlayerImpl::networkState() const {
@@ -1048,6 +1139,9 @@ void WebMediaPlayerImpl::OnHidden() {
   if (!pipeline_.IsRunning())
     return;
 
+  if (suspended_ || suspending_)

[sandersd (OOO until July 31), 2016/01/11 23:04:37]

What's the logic for this change? As currently written, there are some bugs in
this implementation. Example:

  * Playing
  * OnHidden -> Suspending
  * OnShown -> Suspending + Pending Resume
  * OnHidden -> (no action due to new code)
  * Suspended -> Resuming (due to pending resume)
  * Resumed

[hubbe, 2016/01/11 23:39:11]

The logic was DCHECK(!suspending_) triggered.
I'm not sure I grok this example.

[sandersd (OOO until July 31), 2016/01/12 00:05:33]

Where was this DCHECK? No such DCHECK exists in the code currently. If it was
added here, perhaps it's not indicative of a problem?
It's a list of events and state transitions where we imagine that the frame is
being hidden twice within the span it takes to suspend once. In this example the
new code skips later code that would have remove the pending resume, and so when
the suspend finishes it resumes immediately.

[hubbe, 2016/01/12 00:53:04]

My confusion, there is a DCHECK(!resuming_) but no dcheck for !suspsending, I
think I assumed symmetry when I added this.

Will update CL shortly...

+    return;
+
   if (resuming_ || seeking_) {
     pending_suspend_ = true;
     return;
@@ -1101,7 +1195,7 @@ void WebMediaPlayerImpl::OnShown() {
 
   // We may not be suspended if we were not yet subscribed or the pipeline was
   // not yet started when OnHidden() fired.
-  if (!suspended_)
+  if (!suspended_ || resuming_)

[sandersd (OOO until July 31), 2016/01/11 23:04:37]

Same question here. Why is this the correct change?

[hubbe, 2016/01/11 23:39:11]

Frankly, I'm not entirely sure this is the correct change.
It seemed reasonable at the time, but you're the export.

     return;
 
   Resume();
@@ -1140,6 +1234,273 @@ void WebMediaPlayerImpl::Resume() {
                                         time_changed));
 }
 
+#if defined(OS_ANDROID)  // WMPI_CAST
+void WebMediaPlayerImpl::set_media_player_manager(
+    RendererMediaPlayerManagerInterface* media_player_manager) {
+  player_manager_ = media_player_manager;
+  player_id_ = player_manager_->RegisterMediaPlayer(this);
+}
+
+void WebMediaPlayerImpl::requestRemotePlayback() {
+  player_manager_->Seek(player_id_,
+                        base::TimeDelta::FromSecondsD(currentTime()));
+  player_manager_->RequestRemotePlayback(player_id_);
+}
+
+void WebMediaPlayerImpl::requestRemotePlaybackControl() {
+  player_manager_->RequestRemotePlaybackControl(player_id_);
+}
+
+// RendererMediaPlayerInterface implementation
+void WebMediaPlayerImpl::OnMediaMetadataChanged(base::TimeDelta duration,
+                                                int width,
+                                                int height,
+                                                bool success) {}
+void WebMediaPlayerImpl::OnPlaybackComplete() {
+  DVLOG(1) << __FUNCTION__;
+  ended_ = true;
+  client_->timeChanged();
+}
+void WebMediaPlayerImpl::OnBufferingUpdate(int percentage) {
+  DVLOG(1) << __FUNCTION__;
+}
+void WebMediaPlayerImpl::OnSeekRequest(const base::TimeDelta& time_to_seek) {
+  DVLOG(1) << __FUNCTION__;
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  // DCHECK(main_thread_checker_.CalledOnValidThread());
+  client_->requestSeek(time_to_seek.InSecondsF());
+}
+void WebMediaPlayerImpl::OnSeekComplete(const base::TimeDelta& current_time) {
+  DVLOG(1) << __FUNCTION__;
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  remote_time_at_ = base::TimeTicks::Now();
+  remote_time_ = current_time;
+  OnPipelineSeeked(true, PIPELINE_OK);
+}
+
+void WebMediaPlayerImpl::OnMediaError(int error_type) {
+  DVLOG(1) << __FUNCTION__;
+}
+void WebMediaPlayerImpl::OnVideoSizeChanged(int width, int height) {
+  DVLOG(1) << __FUNCTION__;
+}
+
+void WebMediaPlayerImpl::OnTimeUpdate(base::TimeDelta current_timestamp,
+                                      base::TimeTicks current_time_ticks) {
+  DVLOG(1) << __FUNCTION__ << " " << current_timestamp.InSecondsF();
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  remote_time_at_ = current_time_ticks;
+  remote_time_ = current_timestamp;
+}
+
+void WebMediaPlayerImpl::OnPlayerReleased() {
+  DVLOG(1) << __FUNCTION__;
+}
+
+void WebMediaPlayerImpl::OnConnectedToRemoteDevice(
+    const std::string& remote_playback_message) {
+  DVLOG(1) << __FUNCTION__;
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  remote_time_ = base::TimeDelta::FromSecondsD(currentTime());
+  // Set paused so that progress bar doesn't advance while remote playback
+  // is starting.
+  pause();
+  is_remote_ = true;
+  DrawRemotePlaybackText(remote_playback_message);
+  client_->connectedToRemoteDevice();
+}
+
+void WebMediaPlayerImpl::OnDisconnectedFromRemoteDevice() {
+  DVLOG(1) << __FUNCTION__;
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  paused_time_ = base::TimeDelta::FromSecondsD(currentTime());
+  is_remote_ = false;
+  if (suspended_ && !resuming_)
+    Resume();
+  if (ended_ ||
+      paused_time_ + base::TimeDelta::FromMilliseconds(
+                         media::kTimeUpdateInterval * 2) >
+          pipeline_.GetMediaDuration()) {
+    paused_time_ = pipeline_.GetMediaDuration();
+  }
+
+  // We already told the delegate we're paused when remoting started.
+  pipeline_.SetPlaybackRate(0.0);
+  client_->disconnectedFromRemoteDevice();
+  if (!paused_) {
+    paused_ = true;
+    client_->playbackStateChanged();
+  }
+  seek(paused_time_.InSecondsF());
+  // Seek resets ended_, which is not really what we want.
+  if (paused_time_ == pipeline_.GetMediaDuration()) {
+    ended_ = true;
+  }
+}
+
+void WebMediaPlayerImpl::OnDidExitFullscreen() {
+  DVLOG(1) << __FUNCTION__;
+}
+void WebMediaPlayerImpl::OnMediaPlayerPlay() {
+  DVLOG(1) << __FUNCTION__ << " is_remote_ = " << is_remote_;
+  if (is_remote_ && paused_) {
+    paused_ = false;
+    remote_time_at_ = base::TimeTicks::Now();
+    client_->playbackStateChanged();
+  }
+  // Blink expects a timeChanged() in response to a seek().
+  if (should_notify_time_changed_)
+    client_->timeChanged();
+}
+void WebMediaPlayerImpl::OnMediaPlayerPause() {
+  DVLOG(1) << __FUNCTION__ << " is_remote_ = " << is_remote_;
+  if (is_remote_ && !paused_) {
+    paused_ = true;
+    client_->playbackStateChanged();
+  }
+}
+void WebMediaPlayerImpl::OnRemoteRouteAvailabilityChanged(
+    bool routes_available) {
+  DVLOG(1) << __FUNCTION__;
+  client_->remoteRouteAvailabilityChanged(routes_available);
+}
+
+void WebMediaPlayerImpl::ReleaseMediaResources() {}
+
+#if defined(VIDEO_HOLE)
+bool WebMediaPlayerImpl::UpdateBoundaryRectangle() {
+  return false;
+}
+const gfx::RectF WebMediaPlayerImpl::GetBoundaryRectangle() {
+  return gfx::RectF();
+}
+#endif  // defined(VIDEO_HOLE)
+
+void WebMediaPlayerImpl::DrawRemotePlaybackText(
+    const std::string& remote_playback_message) {
+  DVLOG(1) << __FUNCTION__;
+  DCHECK(main_task_runner_->BelongsToCurrentThread());
+  // DCHECK(main_thread_checker_.CalledOnValidThread());
+  if (!video_weblayer_)
+    return;
+
+  // TODO(johnme): Should redraw this frame if the layer bounds change; but
+  // there seems no easy way to listen for the layer resizing (as opposed to
+  // OnVideoSizeChanged, which is when the frame sizes of the video file
+  // change). Perhaps have to poll (on main thread of course)?
+  gfx::Size video_size_css_px = video_weblayer_->bounds();
+  float device_scale_factor = frame_->view()->deviceScaleFactor();
+  // canvas_size will be the size in device pixels when pageScaleFactor == 1
+  gfx::Size canvas_size(
+      static_cast<int>(video_size_css_px.width() * device_scale_factor),
+      static_cast<int>(video_size_css_px.height() * device_scale_factor));
+
+  SkBitmap bitmap;
+  bitmap.allocN32Pixels(canvas_size.width(), canvas_size.height());
+
+  // Create the canvas and draw the "Casting to <Chromecast>" text on it.
+  SkCanvas canvas(bitmap);
+  canvas.drawColor(SK_ColorBLACK);
+
+  const SkScalar kTextSize(40);
+  const SkScalar kMinPadding(40);
+
+  SkPaint paint;
+  paint.setAntiAlias(true);
+  paint.setFilterQuality(kHigh_SkFilterQuality);
+  paint.setColor(SK_ColorWHITE);
+  paint.setTypeface(SkTypeface::CreateFromName("sans", SkTypeface::kBold));
+  paint.setTextSize(kTextSize);
+
+  // Calculate the vertical margin from the top
+  SkPaint::FontMetrics font_metrics;
+  paint.getFontMetrics(&font_metrics);
+  SkScalar sk_vertical_margin = kMinPadding - font_metrics.fAscent;
+
+  // Measure the width of the entire text to display
+  size_t display_text_width = paint.measureText(remote_playback_message.c_str(),
+                                                remote_playback_message.size());
+  std::string display_text(remote_playback_message);
+
+  if (display_text_width + (kMinPadding * 2) > canvas_size.width()) {
+    // The text is too long to fit in one line, truncate it and append ellipsis
+    // to the end.
+
+    // First, figure out how much of the canvas the '...' will take up.
+    const std::string kTruncationEllipsis("\xE2\x80\xA6");
+    SkScalar sk_ellipse_width = paint.measureText(kTruncationEllipsis.c_str(),
+                                                  kTruncationEllipsis.size());
+
+    // Then calculate how much of the text can be drawn with the '...' appended
+    // to the end of the string.
+    SkScalar sk_max_original_text_width(canvas_size.width() -
+                                        (kMinPadding * 2) - sk_ellipse_width);
+    size_t sk_max_original_text_length = paint.breakText(
+        remote_playback_message.c_str(), remote_playback_message.size(),
+        sk_max_original_text_width);
+
+    // Remove the part of the string that doesn't fit and append '...'.
+    display_text.erase(
+        sk_max_original_text_length,
+        remote_playback_message.size() - sk_max_original_text_length);
+    display_text.append(kTruncationEllipsis);
+    display_text_width =
+        paint.measureText(display_text.c_str(), display_text.size());
+  }
+
+  // Center the text horizontally.
+  SkScalar sk_horizontal_margin =
+      (canvas_size.width() - display_text_width) / 2.0;
+  canvas.drawText(display_text.c_str(), display_text.size(),
+                  sk_horizontal_margin, sk_vertical_margin, paint);
+
+  Context3D context_3d;
+  if (!context_3d_cb_.is_null())
+    context_3d = context_3d_cb_.Run();
+  // GPU Process crashed.
+  if (!context_3d.gl)
+    return;
+
+  GLES2Interface* gl = context_3d.gl;
+  GLuint remote_playback_texture_id = 0;
+  gl->GenTextures(1, &remote_playback_texture_id);
+  GLuint texture_target = GL_TEXTURE_2D;
+  gl->BindTexture(texture_target, remote_playback_texture_id);
+  gl->TexParameteri(texture_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+  gl->TexParameteri(texture_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  gl->TexParameteri(texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+  gl->TexParameteri(texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+  {
+    SkAutoLockPixels lock(bitmap);
+    gl->TexImage2D(texture_target, 0 /* level */, GL_RGBA /* internalformat */,
+                   bitmap.width(), bitmap.height(), 0 /* border */,
+                   GL_RGBA /* format */, GL_UNSIGNED_BYTE /* type */,
+                   bitmap.getPixels());
+  }
+
+  gpu::Mailbox texture_mailbox;
+  gl->GenMailboxCHROMIUM(texture_mailbox.name);
+  gl->ProduceTextureCHROMIUM(texture_target, texture_mailbox.name);
+  gl->Flush();
+  gpu::SyncToken texture_mailbox_sync_token(gl->InsertSyncPointCHROMIUM());
+
+  scoped_refptr<VideoFrame> new_frame = VideoFrame::WrapNativeTexture(
+      media::PIXEL_FORMAT_ARGB,
+      gpu::MailboxHolder(texture_mailbox, texture_mailbox_sync_token,
+                         texture_target),
+      media::BindToCurrentLoop(base::Bind(&OnReleaseTexture, context_3d_cb_,
+                                          remote_playback_texture_id)),
+      canvas_size /* coded_size */, gfx::Rect(canvas_size) /* visible_rect */,
+      canvas_size /* natural_size */, base::TimeDelta() /* timestamp */);
+
+  if (!suspended_ && !suspending_)

[liberato (no reviews please), 2016/01/12 22:14:57]

why is this here?

[hubbe, 2016/01/12 22:39:25]

A very existential question.
Check the latest version and see if makes more sense?

+    Suspend();
+  compositor_->PaintFrameUsingOldRenderingPath(new_frame);
+}
+
+#endif  // defined(OS_ANDROID)  // WMPI_CAST
+
 void WebMediaPlayerImpl::DataSourceInitialized(bool success) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
@@ -1321,6 +1682,12 @@ void WebMediaPlayerImpl::UpdatePausedTime() {
 }
 
 void WebMediaPlayerImpl::NotifyPlaybackStarted() {
+#if defined(OS_ANDROID)  // WMPI_CAST
+  // We do not tell our delegates about remote playback, becuase that would
+  // keep the device awake, which is not what we want.
+  if (is_remote_)
+    return;
+#endif
   if (delegate_)
     delegate_->DidPlay(this);
   if (!memory_usage_reporting_timer_.IsRunning()) {
@@ -1331,6 +1698,10 @@ void WebMediaPlayerImpl::NotifyPlaybackStarted() {
 }
 
 void WebMediaPlayerImpl::NotifyPlaybackPaused() {
+#if defined(OS_ANDROID)  // WMPI_CAST
+  if (is_remote_)
+    return;
+#endif
   if (delegate_)
     delegate_->DidPause(this);
   memory_usage_reporting_timer_.Stop();