Merge M59: "Fix incorrect collation of media logs."

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 2790 matching lines @@
     return NULL;
 
   WebPluginParams params_to_use = params;
   params_to_use.mime_type = 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::WebSecurityOrigin security_origin = frame_->GetSecurityOrigin();
   blink::WebMediaStream web_stream =
       GetWebMediaStreamFromWebMediaPlayerSource(source);
   if (!web_stream.IsNull())
-    return CreateWebMediaPlayerForMediaStream(client, sink_id,
-                                              frame_->GetSecurityOrigin());
+    return CreateWebMediaPlayerForMediaStream(client, sink_id, security_origin);
 
   // If |source| was not a MediaStream, it must be a URL.
   // TODO(guidou): Fix this when support for other srcObject types is added.
   DCHECK(source.IsURL());
   blink::WebURL url = source.GetAsURL();
 
   RenderThreadImpl* render_thread = RenderThreadImpl::current();
   // Render thread may not exist in tests, returning nullptr if it does not.
   if (!render_thread)
     return nullptr;
 
   scoped_refptr<media::SwitchableAudioRendererSink> audio_renderer_sink =
       AudioDeviceFactory::NewSwitchableAudioRendererSink(
           AudioDeviceFactory::kSourceMediaElement, routing_id_, 0,
-          sink_id.Utf8(), frame_->GetSecurityOrigin());
+          sink_id.Utf8(), security_origin);
   // 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());
 
+  // This must be created for every new WebMediaPlayer, each instance generates
+  // a new player id which is used to collate logs on the browser side.
+  // TODO(chcunningham, dalecurtis): This should be switched to a unique_ptr
+  // owned by WebMediaPlayer to avoid this confusion. http://crbug.com/711818.
+  scoped_refptr<media::MediaLog> media_log(
+      new RenderMediaLog(url::Origin(security_origin).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;
@@ skipping 19 matching lines @@
       base::TimeDelta::FromMilliseconds(base::GetFieldTrialParamByFeatureAsInt(
           media::kBackgroundVideoTrackOptimization,
           "max_keyframe_distance_media_source_ms",
           base::TimeDelta::FromSeconds(10).InMilliseconds()));
 
   media::WebMediaPlayerParams params(
       base::Bind(&ContentRendererClient::DeferMediaLoad,
                  base::Unretained(GetContentClient()->renderer()),
                  static_cast<RenderFrame*>(this),
                  GetWebMediaPlayerDelegate()->has_played_media()),
-      audio_renderer_sink, GetMediaLog(),
-      render_thread->GetMediaThreadTaskRunner(),
+      audio_renderer_sink, media_log, 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,
       max_keyframe_distance_to_disable_background_video,
       max_keyframe_distance_to_disable_background_video_mse,
       GetWebkitPreferences().enable_instant_source_buffer_gc,
       GetContentClient()->renderer()->AllowMediaSuspend(),
       embedded_media_experience_enabled);
@@ skipping 17 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>(
-          GetMediaLog(), GetDecoderFactory(),
+          media_log, 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>(
-        GetMediaLog(), GetDecoderFactory(),
+        media_log, 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 1710 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(), GetMediaLog()));
+        GetCdmFactory(), GetMediaPermission(),
+        new RenderMediaLog(url::Origin(frame_->GetSecurityOrigin()).GetURL())));
   }
   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 2305 matching lines @@
       policy(info.default_policy),
       replaces_current_history_item(info.replaces_current_history_item),
       history_navigation_in_new_child_frame(
           info.is_history_navigation_in_new_child_frame),
       client_redirect(info.is_client_redirect),
       cache_disabled(info.is_cache_disabled),
       form(info.form),
       source_location(info.source_location) {}
 
 }  // namespace content