Integrate Surface requests with MediaPlayerRenderer

content/browser/media/android/media_player_renderer.cc

 // 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 "content/browser/media/android/media_player_renderer.h"
 
 #include <memory>
 
+#include "content/browser/android/scoped_surface_request_manager.h"
 #include "content/browser/media/android/media_resource_getter_impl.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_client.h"
 
 // TODO(tguilbert): Remove this ID once MediaPlayerManager has been deleted
 // and MediaPlayerBridge updated. See comment in header file.
 constexpr int kUnusedAndIrrelevantPlayerId = 0;
 
 namespace content {
 
 MediaPlayerRenderer::MediaPlayerRenderer(RenderFrameHost* render_frame_host)
     : render_frame_host_(render_frame_host),
       has_error_(false),
+      is_waiting_for_surface_(false),
       weak_factory_(this) {}
 
-MediaPlayerRenderer::~MediaPlayerRenderer() {}
+MediaPlayerRenderer::~MediaPlayerRenderer() {
+  CancelScopedSurfaceRequest();
+}
 
 void MediaPlayerRenderer::Initialize(
     media::DemuxerStreamProvider* demuxer_stream_provider,
     media::RendererClient* client,
     const media::PipelineStatusCB& init_cb) {
   DVLOG(1) << __func__;
   if (demuxer_stream_provider->GetType() !=
       media::DemuxerStreamProvider::Type::URL) {
     DLOG(ERROR) << "DemuxerStreamProvider is not of Type URL";
     init_cb.Run(media::PIPELINE_ERROR_INITIALIZATION_FAILED);
@@ skipping 10 matching lines @@
   media_player_.reset(new media::MediaPlayerBridge(
       kUnusedAndIrrelevantPlayerId, url,
       GURL(),  // first_party_for_cookies
       user_agent,
       false,  // hide_url_log
       this, base::Bind(&MediaPlayerRenderer::OnDecoderResourcesReleased,
                        weak_factory_.GetWeakPtr()),
       GURL(),  // frame_url
       false));   // allow_crendentials
 
-  // TODO(tguilbert): Register and Send the proper surface ID. See
-  // crbug.com/627658
-
   media_player_->Initialize();
   init_cb.Run(media::PIPELINE_OK);
 }
 
 void MediaPlayerRenderer::SetCdm(media::CdmContext* cdm_context,
                                  const media::CdmAttachedCB& cdm_attached_cb) {
   NOTREACHED();
 }
 
 void MediaPlayerRenderer::Flush(const base::Closure& flush_cb) {
@@ skipping 20 matching lines @@
   } else {
     // MediaPlayerBridge's Start() is idempotent.
     media_player_->Start();
 
     // TODO(tguilbert): MediaPlayer's interface allows variable playback rate,
     // but is not currently exposed in the MediaPlayerBridge interface.
     // Investigate wether or not we want to add variable playback speed.
   }
 }
 
+void MediaPlayerRenderer::OnScopedSurfaceRequestCompleted(
+    gl::ScopedJavaSurface surface) {
+  DCHECK(is_waiting_for_surface_);
+  is_waiting_for_surface_ = false;
+  surface_request_token_ = base::UnguessableToken();
+  media_player_->SetVideoSurface(std::move(surface));
+}
+
+base::UnguessableToken MediaPlayerRenderer::InitiateScopedSurfaceRequest() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  CancelScopedSurfaceRequest();
+
+  is_waiting_for_surface_ = true;
+  surface_request_token_ =
+      ScopedSurfaceRequestManager::GetInstance()->RegisterScopedSurfaceRequest(
+          base::Bind(&MediaPlayerRenderer::OnScopedSurfaceRequestCompleted,
+                     weak_factory_.GetWeakPtr()));
+
+  return surface_request_token_;
+}
+
 void MediaPlayerRenderer::SetVolume(float volume) {
   media_player_->SetVolume(volume);
 }
 
 base::TimeDelta MediaPlayerRenderer::GetMediaTime() {
   return media_player_->GetCurrentTime();
 }
 
 bool MediaPlayerRenderer::HasAudio() {
   return media_player_->HasAudio();
@@ skipping 105 matching lines @@
 }
 
 void MediaPlayerRenderer::OnDecoderResourcesReleased(int player_id) {
   // Since we are not using a pool of MediaPlayerAndroid instances, this
   // function is not relevant.
 
   // TODO(tguilbert): Throttle requests, via exponential backoff.
   // See crbug.com/636615.
 }
 
+void MediaPlayerRenderer::CancelScopedSurfaceRequest() {
+  if (!is_waiting_for_surface_)

[dcheng, 2016/10/03 21:11:27]

This bit of state looks like it's always going to be in sync with
|surface_request_token_.is_empty()|. Would it be possible to just use that
directly for determining if there's any work to be done here? 

[tguilbert, 2016/10/03 22:26:19]

You are right. Done!

+    return;
+
+  ScopedSurfaceRequestManager::GetInstance()->UnregisterScopedSurfaceRequest(
+      surface_request_token_);
+  surface_request_token_ = base::UnguessableToken();
+  is_waiting_for_surface_ = false;
+}
+
 }  // namespace content