Move creation of MediaStream renders from MediaStreamImpl to MediaStreamRenderFactory

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 "base/auto_reset.h"
@@ skipping 73 matching lines @@
 #include "third_party/WebKit/public/platform/WebStorageQuotaCallbacks.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/WebURLError.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/web/WebColorSuggestion.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebGlyphCache.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
+#include "third_party/WebKit/public/web/WebMediaStreamRegistry.h"
 #include "third_party/WebKit/public/web/WebNavigationPolicy.h"
 #include "third_party/WebKit/public/web/WebPlugin.h"
 #include "third_party/WebKit/public/web/WebPluginParams.h"
 #include "third_party/WebKit/public/web/WebRange.h"
 #include "third_party/WebKit/public/web/WebScriptSource.h"
 #include "third_party/WebKit/public/web/WebSearchableFormData.h"
 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
 #include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
 #include "third_party/WebKit/public/web/WebView.h"
@@ skipping 291 matching lines @@
       render_view_(render_view->AsWeakPtr()),
       routing_id_(routing_id),
       is_swapped_out_(false),
       render_frame_proxy_(NULL),
       is_detaching_(false),
       cookie_jar_(this),
       selection_text_offset_(0),
       selection_range_(gfx::Range::InvalidRange()),
       handling_select_range_(false),
       notification_provider_(NULL),
-      media_stream_client_(NULL),
       web_user_media_client_(NULL),
       weak_factory_(this) {
   RenderThread::Get()->AddRoute(routing_id_, this);
 
   std::pair<RoutingIDFrameMap::iterator, bool> result =
       g_routing_id_frame_map.Get().insert(std::make_pair(routing_id_, this));
   CHECK(result.second) << "Inserting a duplicate item.";
 
 #if defined(OS_ANDROID)
   new JavaBridgeDispatcher(this);
@@ skipping 212 matching lines @@
     // Mimics the order of events sent by WebKit.
     // See WebCore::Editor::setComposition() for the corresponding code.
     render_view_->focused_pepper_plugin()->HandleCompositionEnd(last_text);
     render_view_->focused_pepper_plugin()->HandleTextInput(last_text);
   }
   pepper_composition_text_.clear();
 }
 
 #endif  // ENABLE_PLUGINS
 
-void RenderFrameImpl::SetMediaStreamClientForTesting(
-    MediaStreamClient* media_stream_client) {
-  DCHECK(!media_stream_client_);
-  DCHECK(!web_user_media_client_);
-  media_stream_client_ = media_stream_client;
-}
-
 bool RenderFrameImpl::Send(IPC::Message* message) {
   if (is_detaching_) {
     delete message;
     return false;
   }
   if (is_swapped_out_ || render_view_->is_swapped_out()) {
     if (!SwappedOutMessages::CanSendWhileSwappedOut(message)) {
       delete message;
       return false;
     }
@@ skipping 713 matching lines @@
   return CreatePlugin(frame, info, params_to_use);
 #else
   return NULL;
 #endif  // defined(ENABLE_PLUGINS)
 }
 
 blink::WebMediaPlayer* RenderFrameImpl::createMediaPlayer(
     blink::WebLocalFrame* frame,
     const blink::WebURL& url,
     blink::WebMediaPlayerClient* client) {
-  WebMediaPlayer* player = CreateWebMediaPlayerForMediaStream(url, client);
-  if (player)
-    return player;
+  blink::WebMediaStream web_stream(
+        blink::WebMediaStreamRegistry::lookupMediaStreamDescriptor(url));
+  if (!web_stream.isNull())
+    return CreateWebMediaPlayerForMediaStream(url, client);
 
 #if defined(OS_ANDROID)
   return CreateAndroidWebMediaPlayer(url, client);
 #else
   WebMediaPlayerParams params(
       base::Bind(&ContentRendererClient::DeferMediaLoad,
                  base::Unretained(GetContentClient()->renderer()),
                  static_cast<RenderFrame*>(this)),
       RenderThreadImpl::current()->GetAudioRendererMixerManager()->CreateInput(
           render_view_->routing_id_, routing_id_));
@@ skipping 1335 matching lines @@
     blink::WebLocalFrame* frame,
     blink::WebRTCPeerConnectionHandler* handler) {
   DCHECK(!frame_ || frame_ == frame);
 #if defined(ENABLE_WEBRTC)
   static_cast<RTCPeerConnectionHandler*>(handler)->associateWithFrame(frame);
 #endif
 }
 
 blink::WebUserMediaClient* RenderFrameImpl::userMediaClient() {
   // This can happen in tests, in which case it's OK to return NULL.
-  if (!InitializeMediaStreamClient())
+  if (!InitializeUserMediaClient())
     return NULL;
 
   return web_user_media_client_;
 }
 
 blink::WebMIDIClient* RenderFrameImpl::webMIDIClient() {
   return render_view_->webMIDIClient();
 }
 
 bool RenderFrameImpl::willCheckAndDispatchMessageEvent(
@@ skipping 643 matching lines @@
     selection_text_ = text;
     selection_text_offset_ = offset;
     selection_range_ = range;
     // This IPC is dispatched by RenderWidetHost, so use its routing ID.
     Send(new ViewHostMsg_SelectionChanged(
         GetRenderWidget()->routing_id(), text, offset, range));
   }
   GetRenderWidget()->UpdateSelectionBounds();
 }
 
-bool RenderFrameImpl::InitializeMediaStreamClient() {
-  if (media_stream_client_)
+bool RenderFrameImpl::InitializeUserMediaClient() {
+  if (web_user_media_client_)
     return true;
 
   if (!RenderThreadImpl::current())  // Will be NULL during unit tests.
     return false;
 
 #if defined(OS_ANDROID)
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableWebRTC))
     return false;
 #endif
 
 #if defined(ENABLE_WEBRTC)
   if (!render_view_->media_stream_dispatcher_) {
     render_view_->media_stream_dispatcher_ =
         new MediaStreamDispatcher(render_view_.get());
   }
 
   MediaStreamImpl* media_stream_impl = new MediaStreamImpl(
       render_view_.get(),
       render_view_->media_stream_dispatcher_,
       RenderThreadImpl::current()->GetPeerConnectionDependencyFactory());
-  media_stream_client_ = media_stream_impl;
   web_user_media_client_ = media_stream_impl;
   return true;
 #else
   return false;
 #endif
 }
 
 WebMediaPlayer* RenderFrameImpl::CreateWebMediaPlayerForMediaStream(
     const blink::WebURL& url,
     WebMediaPlayerClient* client) {
 #if defined(ENABLE_WEBRTC)

[no longer working on chromium, 2014/05/27 12:30:36]

can you improve the #ifs here?
like 

#if !defined(ENABLE_WEBRTC)
  return NULL
#endif

#if defined(OS_ANDROID) && defined(ARCH_CPU_ARMEL)
...
#endif

// WebRtc is enabled.
return new WebMediaPlayerMS(frame_, client, weak_factory_.GetWeakPtr(),

[perkj_chrome, 2014/05/27 13:27:03]

Possibly. But it means that the WebMediaPlayerMS must be compiled even if WEBRTC
is disabled. So I would like to not change this.

-  if (!InitializeMediaStreamClient()) {
-    LOG(ERROR) << "Failed to initialize MediaStreamClient";
-    return NULL;
-  }
-  if (media_stream_client_->IsMediaStream(url)) {
 #if defined(OS_ANDROID) && defined(ARCH_CPU_ARMEL)
-    bool found_neon =
-        (android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_NEON) != 0;
-    UMA_HISTOGRAM_BOOLEAN("Platform.WebRtcNEONFound", found_neon);
+  bool found_neon =
+      (android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_NEON) != 0;
+  UMA_HISTOGRAM_BOOLEAN("Platform.WebRtcNEONFound", found_neon);
 #endif  // defined(OS_ANDROID) && defined(ARCH_CPU_ARMEL)
-    return new WebMediaPlayerMS(frame_, client, weak_factory_.GetWeakPtr(),
-                                media_stream_client_, new RenderMediaLog());
-  }
+  return new WebMediaPlayerMS(frame_, client, weak_factory_.GetWeakPtr(),
+                              new RenderMediaLog(),
+                              CreateRendererFactory());
+#else
+  return NULL;
 #endif  // defined(ENABLE_WEBRTC)
-  return NULL;
+}
+
+scoped_ptr<MediaStreamRendererFactory>
+RenderFrameImpl::CreateRendererFactory() {
+  scoped_ptr<MediaStreamRendererFactory> factory(

[no longer working on chromium, 2014/05/27 12:30:36]

nit, simply do
return scoped_ptr<MediaStreamRendererFactory>(new MediaStreamRendererFactory());

[perkj_chrome, 2014/05/27 13:27:03]

Done.

+      new MediaStreamRendererFactory());
+  return factory.Pass();
 }
 
 #if defined(OS_ANDROID)
 
 WebMediaPlayer* RenderFrameImpl::CreateAndroidWebMediaPlayer(
       const blink::WebURL& url,
       WebMediaPlayerClient* client) {
   GpuChannelHost* gpu_channel_host =
       RenderThreadImpl::current()->EstablishGpuChannelSync(
           CAUSE_FOR_GPU_LAUNCH_VIDEODECODEACCELERATOR_INITIALIZE);
@@ skipping 27 matching lines @@
       weak_factory_.GetWeakPtr(),
       render_view_->media_player_manager_,
       stream_texture_factory,
       RenderThreadImpl::current()->GetMediaThreadMessageLoopProxy(),
       new RenderMediaLog());
 }
 
 #endif
 
 }  // namespace content