Simplify/Cleanup MediaClient

content/renderer/render_frame_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 "content/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 2780 matching lines @@
     return NULL;
 
   WebPluginParams params_to_use = params;
   params_to_use.mimeType = WebString::fromUTF8(mime_type);
   return CreatePlugin(frame, info, params_to_use, nullptr /* throttler */);
 #else
   return NULL;
 #endif  // BUILDFLAG(ENABLE_PLUGINS)
 }
 
+const scoped_refptr<RenderMediaLog>& RenderFrameImpl::GetMediaLog() {
+  if (!media_log_.get()) {
+    media_log_ =
+        new RenderMediaLog(url::Origin(frame_->getSecurityOrigin()).GetURL());
+  }
+
+  return media_log_;
+}
+
 blink::WebMediaPlayer* RenderFrameImpl::createMediaPlayer(
     const blink::WebMediaPlayerSource& source,
     WebMediaPlayerClient* client,
     WebMediaPlayerEncryptedMediaClient* encrypted_client,
     WebContentDecryptionModule* initial_cdm,
     const blink::WebString& sink_id) {
   blink::WebMediaStream web_stream =
       GetWebMediaStreamFromWebMediaPlayerSource(source);
   if (!web_stream.isNull())
     return CreateWebMediaPlayerForMediaStream(client, sink_id,
@@ skipping 15 matching lines @@
           sink_id.utf8(), frame_->getSecurityOrigin());
   // We need to keep a reference to the context provider (see crbug.com/610527)
   // but media/ can't depend on cc/, so for now, just keep a reference in the
   // callback.
   // TODO(piman): replace media::Context3D to scoped_refptr<ContextProvider> in
   // media/ once ContextProvider is in gpu/.
   media::WebMediaPlayerParams::Context3DCB context_3d_cb = base::Bind(
       &GetSharedMainThreadContext3D,
       RenderThreadImpl::current()->SharedMainThreadContextProvider());
 
-  scoped_refptr<media::MediaLog> media_log(
-      new RenderMediaLog(url::Origin(frame_->getSecurityOrigin()).GetURL()));
-
   bool embedded_media_experience_enabled = false;
 #if defined(OS_ANDROID)
   if (!UseMediaPlayerRenderer(url) && !media_surface_manager_)
     media_surface_manager_ = new RendererSurfaceViewManager(this);
   embedded_media_experience_enabled =
       GetWebkitPreferences().embedded_media_experience_enabled;
 #endif  // defined(OS_ANDROID)
 
 #if BUILDFLAG(ENABLE_MEDIA_REMOTING)
   media::mojom::RemotingSourcePtr remoting_source;
   media::mojom::RemotingSourceRequest remoting_source_request(&remoting_source);
   media::mojom::RemoterPtr remoter;
   GetRemoterFactory()->Create(std::move(remoting_source),
                               mojo::MakeRequest(&remoter));
   using RemotingController = media::remoting::RendererController;
   std::unique_ptr<RemotingController> remoting_controller(
       new RemotingController(new media::remoting::SharedSession(
           std::move(remoting_source_request), std::move(remoter))));
   base::WeakPtr<media::MediaObserver> media_observer =
       remoting_controller->GetWeakPtr();
 #else
   base::WeakPtr<media::MediaObserver> media_observer = nullptr;
 #endif
 
   media::WebMediaPlayerParams params(
       base::Bind(&ContentRendererClient::DeferMediaLoad,
                  base::Unretained(GetContentClient()->renderer()),
                  static_cast<RenderFrame*>(this),
                  GetWebMediaPlayerDelegate()->has_played_media()),
-      audio_renderer_sink, media_log, render_thread->GetMediaThreadTaskRunner(),
+      audio_renderer_sink, GetMediaLog(),
+      render_thread->GetMediaThreadTaskRunner(),
       render_thread->GetWorkerTaskRunner(),
       render_thread->compositor_task_runner(), context_3d_cb,
       base::Bind(&v8::Isolate::AdjustAmountOfExternalAllocatedMemory,
                  base::Unretained(blink::mainThreadIsolate())),
       initial_cdm, media_surface_manager_, media_observer,
       // TODO(avayvod, asvitkine): Query the value directly when it is available
       // in the renderer process. See https://crbug.com/681160.
       GetWebkitPreferences().max_keyframe_distance_to_disable_background_video,
       GetWebkitPreferences().enable_instant_source_buffer_gc,
       GetContentClient()->renderer()->AllowMediaSuspend(),
@@ skipping 18 matching lines @@
                    render_thread->EnableStreamTextureCopy(),
                    render_thread->GetStreamTexureFactory(),
                    base::ThreadTaskRunnerHandle::Get()));
 #endif  // defined(OS_ANDROID)
   } else {
 #if defined(ENABLE_MOJO_RENDERER)
 #if BUILDFLAG(ENABLE_RUNTIME_MEDIA_RENDERER_SELECTION)
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kDisableMojoRenderer)) {
       media_renderer_factory = base::MakeUnique<media::DefaultRendererFactory>(
-          media_log, GetDecoderFactory(),
+          GetMediaLog(), GetDecoderFactory(),
           base::Bind(&RenderThreadImpl::GetGpuFactories,
                      base::Unretained(render_thread)));
     }
 #endif  // BUILDFLAG(ENABLE_RUNTIME_MEDIA_RENDERER_SELECTION)
     if (!media_renderer_factory) {
       media_renderer_factory = base::MakeUnique<media::MojoRendererFactory>(
           base::Bind(&RenderThreadImpl::GetGpuFactories,
                      base::Unretained(render_thread)),
           GetMediaInterfaceProvider());
     }
 #else
     media_renderer_factory = base::MakeUnique<media::DefaultRendererFactory>(
-        media_log, GetDecoderFactory(),
+        GetMediaLog(), GetDecoderFactory(),
         base::Bind(&RenderThreadImpl::GetGpuFactories,
                    base::Unretained(render_thread)));
 #endif  // defined(ENABLE_MOJO_RENDERER)
   }
 
 #if BUILDFLAG(ENABLE_MEDIA_REMOTING)
   auto* const remoting_controller_ptr = remoting_controller.get();
   media_renderer_factory =
       base::MakeUnique<media::remoting::AdaptiveRendererFactory>(
           std::move(media_renderer_factory), std::move(remoting_controller));
@@ skipping 1718 matching lines @@
 }
 
 blink::WebEncryptedMediaClient* RenderFrameImpl::encryptedMediaClient() {
   if (!web_encrypted_media_client_) {
     web_encrypted_media_client_.reset(new media::WebEncryptedMediaClientImpl(
         // base::Unretained(this) is safe because WebEncryptedMediaClientImpl
         // is destructed before |this|, and does not give away ownership of the
         // callback.
         base::Bind(&RenderFrameImpl::AreSecureCodecsSupported,
                    base::Unretained(this)),
-        GetCdmFactory(), GetMediaPermission()));
+        GetCdmFactory(), GetMediaPermission(), GetMediaLog()));
   }
   return web_encrypted_media_client_.get();
 }
 
 blink::WebString RenderFrameImpl::userAgentOverride() {
   if (!render_view_->webview() || !render_view_->webview()->mainFrame() ||
       render_view_->renderer_preferences_.user_agent_override.empty()) {
     return blink::WebString();
   }
 
@@ skipping 2301 matching lines @@
       policy(info.defaultPolicy),
       replaces_current_history_item(info.replacesCurrentHistoryItem),
       history_navigation_in_new_child_frame(
           info.isHistoryNavigationInNewChildFrame),
       client_redirect(info.isClientRedirect),
       cache_disabled(info.isCacheDisabled),
       form(info.form),
       source_location(info.sourceLocation) {}
 
 }  // namespace content