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(WIMPI_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(WIMPI_CAST)
+// File-static function is to allow it to run even after WMPA is deleted.
+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.
+  gl->ShallowFlushCHROMIUM();
+}
+#endif  // WIMPI_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(WIMPI_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(WIMPI_CAST)
+  player_manager_->Initialize(MEDIA_PLAYER_TYPE_URL, player_id_, url,
+                              frame_->document().firstPartyForCookies(), 0,
+                              frame_->document().url(), true);
+
+  is_player_initialized_ = true;
+#endif  // defined(WIMPI_CAST)
 }
 
 void WebMediaPlayerImpl::play() {
   DVLOG(1) << __FUNCTION__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
+#if defined(WIMPI_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(WIMPI_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(WIMPI_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(WIMPI_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(WIMPI_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_)
+    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_)
     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(WIMPI_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(

[DaleCurtis, 2016/01/07 21:28:39]

Can you just abstract the existing code in WebMediaPlayerAndroid into
MediaCodecUtil or something similar?

[hubbe, 2016/01/11 22:47:24]

I think it can, but it will not make it easier to delete this code later. Do you
still want me to break it out?

+    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_)
+    Suspend();
+  compositor_->PaintFrameUsingOldRenderingPath(new_frame);
+}
+
+#endif  // defined(WIMPI_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(WIMPI_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_)

[liberato (no reviews please), 2016/01/08 16:37:58]

the comment makes me expect that it should check for |is_remote_|==true rather
than ==false.

[hubbe, 2016/01/11 22:47:24]

Good catch, fixed.
(Testing...)

+    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(WIMPI_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