[DO NOT COMMIT] Initial MediaPlayerRenderer plumbing and basic features

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..80fc34bcab23b3c02100706ed0f7931ae46cef8c
--- /dev/null
+++ b/media/base/android/media_player_renderer.cc
@@ -0,0 +1,235 @@
+// 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 "media/base/android/url_demuxer_stream.h"
+#include "mojo/common/user_agent.h"
+
+namespace media {
+
+MediaPlayerRenderer::MediaPlayerRenderer(
+    content::RenderFrameHost* render_frame_host)
+    : 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__;
+  DemuxerStream* stream =
+      demuxer_stream_provider->GetStream(DemuxerStream::Type::URL);
+  if (stream) {
+    // TODO(tguilbert): FOR REVIEW: are c-style casts allowed?
+    UrlDemuxerStream* temp = (UrlDemuxerStream*)stream;
+    url_ = temp->url();
+    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));
+
+    media_player_->SetVideoSurface(content::GetViewSurface(surface_id_));

[liberato (no reviews please), 2016/06/23 21:31:38]

i think that using SV initially during development was a very good idea. 
unfortunately, switching between SV and ST might be somewhat harder.

if you intend to include ST support in v1, then you might want to consider
transitioning this CL to use SurfaceTexture exclusively.  it could avoid a lot
of edge cases.  such ideas arrive thanks to a morning conversation with sandersd
and watk :)

we can add SV support later, if usage stats are high enough.

+    media_player_->Initialize();
+    init_cb.Run(PIPELINE_OK);
+  } else {
+    LOG(ERROR) << "DemuxerStreamProvider does not have a URL stream";
+    init_cb.Run(PIPELINE_ERROR_INITIALIZATION_FAILED);
+  }
+}
+
+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);
+  }
+}
+
+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 return false.
+  return true;
+}
+
+void MediaPlayerRenderer::OnDecoderResourcesReleased(int player_id) {
+  // TODO(tguilbert): Since we are not using a pool of MediaPlayerAndroid
+  // instances, this function not be relevant. Investigate whether the use of
+  // the MediaThrottler is needed.
+}
+
+}  // namespace media