[DO NOT COMMIT] MediaPlayerRenderer using StreamTextures.

media/base/android/media_player_renderer.cc

Index: media/base/android/media_player_renderer.cc
diff --git a/media/base/android/media_player_renderer.cc b/media/base/android/media_player_renderer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..fbe74b1d36e0d7709b875c71e7b7bc46cd09666d
--- /dev/null
+++ b/media/base/android/media_player_renderer.cc
@@ -0,0 +1,249 @@
+// Copyright 2016 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/base/android/media_player_renderer.h"
+
+#include <memory>
+
+#include "content/browser/android/child_process_launcher_android.h"
+#include "content/browser/media/android/media_resource_getter_impl.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/storage_partition.h"
+#include "content/public/browser/web_contents.h"
+#include "mojo/common/user_agent.h"
+
+namespace media {
+
+gl::ScopedJavaSurface MediaPlayerRenderer::surface_for_prototype;
+
+MediaPlayerRenderer::MediaPlayerRenderer(
+    content::RenderFrameHost* render_frame_host)
+    : surface_has_been_set_for_prototype(false),
+      render_frame_host_(render_frame_host),
+      duration_(base::TimeDelta::FromMicroseconds(0)),
+      weak_factory_(this) {}
+
+MediaPlayerRenderer::~MediaPlayerRenderer() {}
+
+void MediaPlayerRenderer::Initialize(
+    DemuxerStreamProvider* demuxer_stream_provider,
+    RendererClient* client,
+    const PipelineStatusCB& init_cb) {
+  DVLOG(1) << __FUNCTION__;
+  if (demuxer_stream_provider->GetType() == DemuxerStreamProvider::Type::URL) {
+    url_ = demuxer_stream_provider->GetUrl();
+    renderer_client_ = client;
+
+    // TODO(tguilbert): Use appropriate parameters (instead of GURL).
+    const int kIrrelevantMediaPlayerId = 0;
+    media_player_.reset(new MediaPlayerBridge(
+        kIrrelevantMediaPlayerId, url_, GURL(),
+        // TODO(tguilbert): What is the appropriate user agent to use?
+        mojo::common::GetUserAgent(), false, this,
+        base::Bind(&MediaPlayerRenderer::OnDecoderResourcesReleased,
+                   weak_factory_.GetWeakPtr()),
+        GURL(), false, 0));
+
+    // TODO(tguilbert): Register and Send the proper surface ID. See
+    // crbug.com/627658
+    SetSurfaceInternal_ForPrototype();
+
+    // media_player_->SetVideoSurface(content::GetViewSurface(surface_id_));
+    media_player_->Initialize();
+    init_cb.Run(PIPELINE_OK);
+  } else {
+    LOG(ERROR) << "DemuxerStreamProvider is not of Type URL";
+    init_cb.Run(PIPELINE_ERROR_INITIALIZATION_FAILED);
+  }
+}
+
+void MediaPlayerRenderer::SetSurfaceInternal_ForPrototype() {
+  if (!surface_for_prototype.IsEmpty() && !surface_has_been_set_for_prototype) {
+    media_player_->SetVideoSurface(
+        std::move(MediaPlayerRenderer::surface_for_prototype));
+    surface_has_been_set_for_prototype = true;
+  }
+}
+
+void MediaPlayerRenderer::SetCdm(CdmContext* cdm_context,
+                                 const CdmAttachedCB& cdm_attached_cb) {
+  DVLOG(2) << __FUNCTION__;
+  NOTREACHED();
+}
+
+void MediaPlayerRenderer::SetSurfaceId(int surface_id) {
+  surface_id_ = surface_id;
+}
+
+void MediaPlayerRenderer::Flush(const base::Closure& flush_cb) {
+  DVLOG(2) << __FUNCTION__;
+  flush_cb.Run();
+}
+
+void MediaPlayerRenderer::StartPlayingFrom(base::TimeDelta time) {
+  DVLOG(2) << __FUNCTION__;
+  // TODO(tguilbert): MediaPlayer's Start() is idempotent, but investigate
+  // MediaPlayerBridge's idempotency when it is in an error state. (It seems
+  // that calling start after receiving an error is counted as a new error).
+  //
+  // TODO(tguilbert): make sure IsPlayerReady() is true, and handle the cases
+  // when it's not.
+
+  media_player_->Start();
+  media_player_->SeekTo(time);
+}
+
+void MediaPlayerRenderer::SetPlaybackRate(double playback_rate) {
+  DVLOG(2) << __FUNCTION__;
+  // TODO(tguilbert): Should the state be save in order to prevent redundant
+  // calls?
+  if (playback_rate == 0) {
+    media_player_->Pause(false);
+  } else {
+    //
+    // TODO(tguilbert): Make sure IsPlayerReady() is true, and handle the cases
+    // when it's not.
+    media_player_->Start();
+  }
+}
+
+void MediaPlayerRenderer::SetVolume(float volume) {
+  media_player_->SetVolume(volume);
+}
+
+base::TimeDelta MediaPlayerRenderer::GetMediaTime() {
+  return media_player_->GetCurrentTime();
+}
+
+bool MediaPlayerRenderer::HasAudio() {
+  return media_player_->HasAudio();
+}
+
+bool MediaPlayerRenderer::HasVideo() {
+  return media_player_->HasVideo();
+}
+
+MediaResourceGetter* MediaPlayerRenderer::GetMediaResourceGetter() {
+  DVLOG(1) << __FUNCTION__;
+
+  if (!media_resource_getter_.get()) {
+    content::WebContents* web_contents =
+        content::WebContents::FromRenderFrameHost(render_frame_host_);
+    content::RenderProcessHost* host = web_contents->GetRenderProcessHost();
+    content::BrowserContext* context = host->GetBrowserContext();
+    content::StoragePartition* partition = host->GetStoragePartition();
+    storage::FileSystemContext* file_system_context =
+        partition ? partition->GetFileSystemContext() : NULL;
+    // Eventually this needs to be fixed to pass the correct frame rather
+    // than just using the main frame.
+    media_resource_getter_.reset(new content::MediaResourceGetterImpl(
+        context, file_system_context, host->GetID(),
+        web_contents->GetMainFrame()->GetRoutingID()));
+  }
+  return media_resource_getter_.get();
+}
+
+MediaUrlInterceptor* MediaPlayerRenderer::GetMediaUrlInterceptor() {
+  DVLOG(1) << __FUNCTION__;
+  return nullptr;
+}
+
+void MediaPlayerRenderer::OnTimeUpdate(int player_id,
+                                       base::TimeDelta current_timestamp,
+                                       base::TimeTicks current_time_ticks) {
+  // TODO(tguilbert): Handle this if necessary.
+}
+
+void MediaPlayerRenderer::OnMediaMetadataChanged(int player_id,
+                                                 base::TimeDelta duration,
+                                                 int width,
+                                                 int height,
+                                                 bool success) {
+  DVLOG(1) << __FUNCTION__ << " { duration: " << duration.InMilliseconds()
+           << "(ms) witdh: " << width << ", height: " << height
+           << ", success: " << success << "}";
+  if (duration_ != duration) {
+    duration_ = duration;
+    renderer_client_->OnDurationChange(duration);
+  }
+  if (!surface_has_been_set_for_prototype) {
+    SetSurfaceInternal_ForPrototype();
+  }
+}
+
+void MediaPlayerRenderer::OnPlaybackComplete(int player_id) {
+  DVLOG(1) << __FUNCTION__;
+  renderer_client_->OnEnded();
+}
+
+void MediaPlayerRenderer::OnMediaInterrupted(int player_id) {
+  DVLOG(1) << __FUNCTION__;
+  // TODO(tguilbert): Handle this if necessary.
+}
+
+void MediaPlayerRenderer::OnBufferingUpdate(int player_id, int percentage) {
+  DVLOG(1) << __FUNCTION__;
+  // TODO(tguilbert): Determine proper threshold for triggering the have enough,
+  // and only trigger it once.
+  renderer_client_->OnBufferingStateChange(BUFFERING_HAVE_ENOUGH);
+}
+
+void MediaPlayerRenderer::OnSeekComplete(int player_id,
+                                         const base::TimeDelta& current_time) {
+  DVLOG(1) << __FUNCTION__;
+  // TODO(tguilbert): Handle this if necessary.
+}
+
+void MediaPlayerRenderer::OnError(int player_id, int error) {
+  DVLOG(1) << __FUNCTION__ << " Error: " << error;
+  // TODO(tguilbert): Use more detailed errors if needed.
+  //
+  // TODO(tguilbert): Save the error state and properly error out or reset on
+  // future calls.
+
+  // Some errors are forwarded to the MediaPlayerListener, but are of no
+  // importance to us. Ignore these errors, which are reported as error 0 by
+  // MediaPlayerListener.
+  if (error)
+    renderer_client_->OnError(PIPELINE_ERROR_COULD_NOT_RENDER);
+}
+
+void MediaPlayerRenderer::OnVideoSizeChanged(int player_id,
+                                             int width,
+                                             int height) {
+  DVLOG(2) << __FUNCTION__;
+  renderer_client_->OnVideoNaturalSizeChange(gfx::Size(width, height));
+}
+
+void MediaPlayerRenderer::OnWaitingForDecryptionKey(int player_id) {
+  DVLOG(1) << __FUNCTION__;
+  NOTREACHED();
+}
+
+MediaPlayerAndroid* MediaPlayerRenderer::GetFullscreenPlayer() {
+  NOTREACHED();
+  return nullptr;
+}
+
+MediaPlayerAndroid* MediaPlayerRenderer::GetPlayer(int player_id) {
+  NOTREACHED();
+  return nullptr;
+}
+
+bool MediaPlayerRenderer::RequestPlay(int player_id,
+                                      base::TimeDelta duration,
+                                      bool has_audio) {
+  // TODO(tguilbert): Determine wheter or not this function should ever
+  // return false.
+  return true;
+}
+
+void MediaPlayerRenderer::OnDecoderResourcesReleased(int player_id) {
+  // TODO(tguilbert): Since we are not using a pool of MediaPlayerAndroid
+  // instances, this function is not relevant. Investigate whether the use of
+  // the MediaThrottler is needed.
+}
+
+}  // namespace media