Support CAST+WMPI on android

media/blink/webmediaplayer_impl.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 "media/blink/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <string>
@@ skipping 41 matching lines @@
 #include "third_party/WebKit/public/platform/WebSize.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
 #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 {
 
 // Limits the range of playback rate.
 //
 // TODO(kylep): Revisit these.
 //
 // Vista has substantially lower performance than XP or Windows7.  If you speed
 // up a video too much, it can't keep up, and rendering stops updating except on
 // the time bar. For really high speeds, audio becomes a bottleneck and we just
 // use up the data we have, which may not achieve the speed requested, but will
 // not crash the tab.
 //
 // A very slow speed, ie 0.00000001x, causes the machine to lock up. (It seems
 // like a busy loop). It gets unresponsive, although its not completely dead.
 //
 // Also our timers are not very accurate (especially for ogg), which becomes
 // evident at low speeds and on Vista. Since other speeds are risky and outside
 // the norms, we think 1/16x to 16x is a safe and useful range for now.
 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);
   }
 }
 
+#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;
+
+  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
 
-namespace media {
-
 class BufferedDataSourceHostImpl;
 
 #define STATIC_ASSERT_MATCHING_ENUM(name, name2)                    \
   static_assert(static_cast<int>(WebMediaPlayer::CORSMode##name) == \
                     static_cast<int>(UrlData::name2),               \
                 "mismatching enum values: " #name)
 STATIC_ASSERT_MATCHING_ENUM(Unspecified, CORS_UNSPECIFIED);
 STATIC_ASSERT_MATCHING_ENUM(Anonymous, CORS_ANONYMOUS);
 STATIC_ASSERT_MATCHING_ENUM(UseCredentials, CORS_USE_CREDENTIALS);
 #undef STATIC_ASSERT_MATCHING_ENUM
@@ skipping 84 matching lines @@
   // e.g. GetCurrentFrameFromCompositor(). See http://crbug.com/434861
 
   // Use the null sink if no sink was provided.
   audio_source_provider_ = new WebAudioSourceProviderImpl(
       params.audio_renderer_sink().get()
           ? params.audio_renderer_sink()
           : new NullAudioSink(media_task_runner_));
 }
 
 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());
 
   if (delegate_) {
     delegate_->RemoveObserver(this);
     delegate_->PlayerGone(this);
   }
 
   // Abort any pending IO so stopping the pipeline doesn't get blocked.
@@ skipping 73 matching lines @@
     data_source_.reset(new BufferedDataSource(
         url, static_cast<BufferedResourceLoader::CORSMode>(cors_mode),
         main_task_runner_, frame_, media_log_.get(),
         &buffered_data_source_host_,
         base::Bind(&WebMediaPlayerImpl::NotifyDownloading, AsWeakPtr())));
   }
   data_source_->SetPreload(preload_);
   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();
 
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::PLAY));
 
   if (delegate_ && playback_rate_ > 0)
     NotifyPlaybackStarted();
 }
 
 void WebMediaPlayerImpl::pause() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   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();
 
   media_log_->AddEvent(media_log_->CreateEvent(MediaLogEvent::PAUSE));
 
   if (!was_already_paused && delegate_)
     NotifyPlaybackPaused();
 }
 
 bool WebMediaPlayerImpl::supportsSave() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   return supports_save_;
 }
 
 void WebMediaPlayerImpl::seek(double seconds) {
   DVLOG(1) << __FUNCTION__ << "(" << seconds << "s)";
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   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.
     bool is_suspended = suspended_ && !resuming_;
 
     // If we are currently seeking or resuming to |new_seek_time|, skip the
     // seek (except for MSE, which always seeks).
     if (!is_suspended && new_seek_time == seek_time_) {
       if (chunk_demuxer_) {
         // Don't suppress any redundant in-progress MSE seek. There could have
@@ skipping 53 matching lines @@
       return;
     }
   }
 
   seeking_ = true;
   seek_time_ = new_seek_time;
 
   if (chunk_demuxer_)
     chunk_demuxer_->StartWaitingForSeek(seek_time_);
 
-  // Kick off the asynchronous seek!
   pipeline_.Seek(seek_time_, BIND_TO_RENDER_LOOP1(
                                  &WebMediaPlayerImpl::OnPipelineSeeked, true));
 }
 
 void WebMediaPlayerImpl::setRate(double rate) {
   DVLOG(1) << __FUNCTION__ << "(" << rate << ")";
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   // TODO(kylep): Remove when support for negatives is added. Also, modify the
   // following checks so rewind uses reasonable values also.
@@ skipping 96 matching lines @@
 
 blink::WebSize WebMediaPlayerImpl::naturalSize() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   return blink::WebSize(pipeline_metadata_.natural_size);
 }
 
 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;
 }
 
 bool WebMediaPlayerImpl::seeking() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing)
     return false;
 
   return seeking_;
@@ skipping 27 matching lines @@
     return duration();
 
   // We know the current seek time better than pipeline: pipeline may processing
   // an earlier seek before a pending seek has been started, or it might not yet
   // have the current seek time returnable via GetMediaTime().
   if (seeking()) {
     return pending_seek_ ? pending_seek_time_.InSecondsF()
                          : 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 {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   return network_state_;
 }
 
 WebMediaPlayer::ReadyState WebMediaPlayerImpl::readyState() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   return ready_state_;
@@ skipping 441 matching lines @@
 #endif  // !defined(OS_ANDROID)
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableMediaSuspend)) {
     return;
   }
 
   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;
   }
 
   if (pending_resume_) {
     pending_resume_ = false;
     return;
   }
 
@@ skipping 33 matching lines @@
     return;
   }
 
   if (pending_suspend_) {
     pending_suspend_ = false;
     return;
   }
 
   // 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();
 }
 
 void WebMediaPlayerImpl::Resume() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   CHECK(suspended_);
   CHECK(!resuming_);
 
@@ skipping 18 matching lines @@
 
   if (chunk_demuxer_)
     chunk_demuxer_->StartWaitingForSeek(seek_time_);
 
   resuming_ = true;
   pipeline_.Resume(CreateRenderer(), seek_time_,
                    BIND_TO_RENDER_LOOP1(&WebMediaPlayerImpl::OnPipelineSeeked,
                                         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());
 
   if (!success) {
     SetNetworkState(WebMediaPlayer::NetworkStateFormatError);
     return;
   }
 
   StartPipeline();
@@ skipping 161 matching lines @@
 
   // pause() may be called after playback has ended and the HTMLMediaElement
   // requires that currentTime() == duration() after ending.  We want to ensure
   // |paused_time_| matches currentTime() in this case or a future seek() may
   // incorrectly discard what it thinks is a seek to the existing time.
   paused_time_ =
       ended_ ? pipeline_.GetMediaDuration() : pipeline_.GetMediaTime();
 }
 
 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()) {
     memory_usage_reporting_timer_.Start(FROM_HERE,
                                         base::TimeDelta::FromSeconds(2), this,
                                         &WebMediaPlayerImpl::ReportMemoryUsage);
   }
 }
 
 void WebMediaPlayerImpl::NotifyPlaybackPaused() {
+#if defined(OS_ANDROID)  // WMPI_CAST
+  if (is_remote_)
+    return;
+#endif
   if (delegate_)
     delegate_->DidPause(this);
   memory_usage_reporting_timer_.Stop();
   ReportMemoryUsage();
 }
 
 void WebMediaPlayerImpl::ReportMemoryUsage() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   // About base::Unretained() usage below: We destroy |demuxer_| on the main
@@ skipping 24 matching lines @@
            << ", Video: " << stats.video_memory_usage << ", DataSource: "
            << (data_source_ ? data_source_->GetMemoryUsage() : 0)
            << ", Demuxer: " << demuxer_memory_usage;
 
   const int64_t delta = current_memory_usage - last_reported_memory_usage_;
   last_reported_memory_usage_ = current_memory_usage;
   adjust_allocated_memory_cb_.Run(delta);
 }
 
 }  // namespace media