Add MediaServiceThrottler

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 "base/callback_helpers.h"
 #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"
+#include "media/base/android/media_service_throttler.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),
       weak_factory_(this) {}
 
 MediaPlayerRenderer::~MediaPlayerRenderer() {
   CancelScopedSurfaceRequest();
 }
 
 void MediaPlayerRenderer::Initialize(
     media::DemuxerStreamProvider* demuxer_stream_provider,
     media::RendererClient* client,
     const media::PipelineStatusCB& init_cb) {
   DVLOG(1) << __func__;
+
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(!pending_init_cb_);
+
+  renderer_client_ = client;
+
   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);
     return;
   }
 
-  media::MediaUrlParams url_params =
-      demuxer_stream_provider->GetMediaUrlParams();
-  renderer_client_ = client;
+  pending_init_cb_ = init_cb;

[DaleCurtis, 2016/11/11 23:32:15]

Bind it into CreateMediaPlayer instead?

[tguilbert, 2016/11/14 23:18:07]

Done.

+
+  base::TimeDelta creation_delay =
+      media::MediaServiceThrottler::GetInstance()->GetDelayForClientCreation();
+
+  if (creation_delay.is_zero()) {
+    CreateUnderlyingMediaPlayer(demuxer_stream_provider->GetMediaUrlParams());
+    return;
+  }
+
+  BrowserThread::PostDelayedTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&MediaPlayerRenderer::CreateUnderlyingMediaPlayer,
+                 weak_factory_.GetWeakPtr(),
+                 demuxer_stream_provider->GetMediaUrlParams()),
+      creation_delay);
+}
+
+void MediaPlayerRenderer::CreateUnderlyingMediaPlayer(
+    const media::MediaUrlParams& url_params) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(pending_init_cb_);
 
   const std::string user_agent = GetContentClient()->GetUserAgent();
 
   media_player_.reset(new media::MediaPlayerBridge(
       kUnusedAndIrrelevantPlayerId, url_params.media_url,
       url_params.first_party_for_cookies, user_agent,
       false,  // hide_url_log
       this, base::Bind(&MediaPlayerRenderer::OnDecoderResourcesReleased,
                        weak_factory_.GetWeakPtr()),
       GURL(),  // frame_url
       true));  // allow_crendentials
 
   media_player_->Initialize();
-  init_cb.Run(media::PIPELINE_OK);
+  base::ResetAndReturn(&pending_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) {
   DVLOG(3) << __func__;
   flush_cb.Run();
@@ skipping 173 matching lines @@
 void MediaPlayerRenderer::CancelScopedSurfaceRequest() {
   if (!surface_request_token_)
     return;
 
   ScopedSurfaceRequestManager::GetInstance()->UnregisterScopedSurfaceRequest(
       surface_request_token_);
   surface_request_token_ = base::UnguessableToken();
 }
 
 }  // namespace content