OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/renderer/render_frame_impl.h" | 5 #include "content/renderer/render_frame_impl.h" |
6 | 6 |
7 #include <map> | 7 #include <map> |
8 #include <string> | 8 #include <string> |
9 #include <utility> | 9 #include <utility> |
10 #include <vector> | 10 #include <vector> |
(...skipping 232 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
243 #if defined(ENABLE_MOJO_RENDERER) | 243 #if defined(ENABLE_MOJO_RENDERER) |
244 #include "media/mojo/clients/mojo_renderer_factory.h" // nogncheck | 244 #include "media/mojo/clients/mojo_renderer_factory.h" // nogncheck |
245 #else | 245 #else |
246 #include "media/renderers/default_renderer_factory.h" | 246 #include "media/renderers/default_renderer_factory.h" |
247 #endif | 247 #endif |
248 | 248 |
249 #if defined(ENABLE_MOJO_AUDIO_DECODER) || defined(ENABLE_MOJO_VIDEO_DECODER) | 249 #if defined(ENABLE_MOJO_AUDIO_DECODER) || defined(ENABLE_MOJO_VIDEO_DECODER) |
250 #include "media/mojo/clients/mojo_decoder_factory.h" // nogncheck | 250 #include "media/mojo/clients/mojo_decoder_factory.h" // nogncheck |
251 #endif | 251 #endif |
252 | 252 |
| 253 #if defined(ENABLE_MEDIA_REMOTING) |
| 254 #include "media/remoting/remoting_controller.h" |
| 255 #include "media/remoting/remoting_renderer_factory.h" |
| 256 #endif |
| 257 |
253 using blink::WebCachePolicy; | 258 using blink::WebCachePolicy; |
254 using blink::WebContentDecryptionModule; | 259 using blink::WebContentDecryptionModule; |
255 using blink::WebContextMenuData; | 260 using blink::WebContextMenuData; |
256 using blink::WebCString; | 261 using blink::WebCString; |
257 using blink::WebData; | 262 using blink::WebData; |
258 using blink::WebDataSource; | 263 using blink::WebDataSource; |
259 using blink::WebDocument; | 264 using blink::WebDocument; |
260 using blink::WebDOMEvent; | 265 using blink::WebDOMEvent; |
261 using blink::WebDOMMessageEvent; | 266 using blink::WebDOMMessageEvent; |
262 using blink::WebElement; | 267 using blink::WebElement; |
(...skipping 2348 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2611 return NULL; | 2616 return NULL; |
2612 | 2617 |
2613 WebPluginParams params_to_use = params; | 2618 WebPluginParams params_to_use = params; |
2614 params_to_use.mimeType = WebString::fromUTF8(mime_type); | 2619 params_to_use.mimeType = WebString::fromUTF8(mime_type); |
2615 return CreatePlugin(frame, info, params_to_use, nullptr /* throttler */); | 2620 return CreatePlugin(frame, info, params_to_use, nullptr /* throttler */); |
2616 #else | 2621 #else |
2617 return NULL; | 2622 return NULL; |
2618 #endif // defined(ENABLE_PLUGINS) | 2623 #endif // defined(ENABLE_PLUGINS) |
2619 } | 2624 } |
2620 | 2625 |
| 2626 #if defined(ENABLE_MEDIA_REMOTING) |
| 2627 std::unique_ptr<media::RemotingController> |
| 2628 RenderFrameImpl::CreateRemotingController() { |
| 2629 media::mojom::RemotingSourcePtr remoting_source; |
| 2630 media::mojom::RemotingSourceRequest remoting_source_request = |
| 2631 mojo::GetProxy(&remoting_source); |
| 2632 media::mojom::RemoterPtr remoter; |
| 2633 GetRemoterFactory()->Create(std::move(remoting_source), |
| 2634 mojo::GetProxy(&remoter)); |
| 2635 return base::MakeUnique<media::RemotingController>( |
| 2636 std::move(remoting_source_request), std::move(remoter)); |
| 2637 } |
| 2638 #endif |
| 2639 |
2621 blink::WebMediaPlayer* RenderFrameImpl::createMediaPlayer( | 2640 blink::WebMediaPlayer* RenderFrameImpl::createMediaPlayer( |
2622 const blink::WebMediaPlayerSource& source, | 2641 const blink::WebMediaPlayerSource& source, |
2623 WebMediaPlayerClient* client, | 2642 WebMediaPlayerClient* client, |
2624 WebMediaPlayerEncryptedMediaClient* encrypted_client, | 2643 WebMediaPlayerEncryptedMediaClient* encrypted_client, |
2625 WebContentDecryptionModule* initial_cdm, | 2644 WebContentDecryptionModule* initial_cdm, |
2626 const blink::WebString& sink_id) { | 2645 const blink::WebString& sink_id) { |
2627 blink::WebMediaStream web_stream = | 2646 blink::WebMediaStream web_stream = |
2628 GetWebMediaStreamFromWebMediaPlayerSource(source); | 2647 GetWebMediaStreamFromWebMediaPlayerSource(source); |
2629 if (!web_stream.isNull()) | 2648 if (!web_stream.isNull()) |
2630 return CreateWebMediaPlayerForMediaStream(client, sink_id, | 2649 return CreateWebMediaPlayerForMediaStream(client, sink_id, |
(...skipping 18 matching lines...) Expand all Loading... |
2649 media::WebMediaPlayerParams::Context3DCB context_3d_cb = base::Bind( | 2668 media::WebMediaPlayerParams::Context3DCB context_3d_cb = base::Bind( |
2650 &GetSharedMainThreadContext3D, | 2669 &GetSharedMainThreadContext3D, |
2651 RenderThreadImpl::current()->SharedMainThreadContextProvider()); | 2670 RenderThreadImpl::current()->SharedMainThreadContextProvider()); |
2652 | 2671 |
2653 scoped_refptr<media::MediaLog> media_log(new RenderMediaLog( | 2672 scoped_refptr<media::MediaLog> media_log(new RenderMediaLog( |
2654 blink::WebStringToGURL(frame_->getSecurityOrigin().toString()))); | 2673 blink::WebStringToGURL(frame_->getSecurityOrigin().toString()))); |
2655 | 2674 |
2656 #if defined(OS_ANDROID) | 2675 #if defined(OS_ANDROID) |
2657 if (UseWebMediaPlayerImpl(url) && !media_surface_manager_) | 2676 if (UseWebMediaPlayerImpl(url) && !media_surface_manager_) |
2658 media_surface_manager_ = new RendererSurfaceViewManager(this); | 2677 media_surface_manager_ = new RendererSurfaceViewManager(this); |
2659 #endif | 2678 #endif // defined(OS_ANDROID) |
| 2679 |
| 2680 #if defined(ENABLE_MEDIA_REMOTING) |
| 2681 std::unique_ptr<media::RemotingController> remoting_controller = |
| 2682 CreateRemotingController(); |
| 2683 base::WeakPtr<media::MediaObserver> media_observer = |
| 2684 remoting_controller->GetWeakPtr(); |
| 2685 #else |
| 2686 base::WeakPtr<media::MediaObserver> media_observer = nullptr; |
| 2687 #endif // defined(ENABLE_MEDIA_REMOTING) |
| 2688 |
2660 media::WebMediaPlayerParams params( | 2689 media::WebMediaPlayerParams params( |
2661 base::Bind(&ContentRendererClient::DeferMediaLoad, | 2690 base::Bind(&ContentRendererClient::DeferMediaLoad, |
2662 base::Unretained(GetContentClient()->renderer()), | 2691 base::Unretained(GetContentClient()->renderer()), |
2663 static_cast<RenderFrame*>(this), | 2692 static_cast<RenderFrame*>(this), |
2664 GetWebMediaPlayerDelegate()->has_played_media()), | 2693 GetWebMediaPlayerDelegate()->has_played_media()), |
2665 audio_renderer_sink, media_log, render_thread->GetMediaThreadTaskRunner(), | 2694 audio_renderer_sink, media_log, render_thread->GetMediaThreadTaskRunner(), |
2666 render_thread->GetWorkerTaskRunner(), | 2695 render_thread->GetWorkerTaskRunner(), |
2667 render_thread->compositor_task_runner(), context_3d_cb, | 2696 render_thread->compositor_task_runner(), context_3d_cb, |
2668 base::Bind(&v8::Isolate::AdjustAmountOfExternalAllocatedMemory, | 2697 base::Bind(&v8::Isolate::AdjustAmountOfExternalAllocatedMemory, |
2669 base::Unretained(blink::mainThreadIsolate())), | 2698 base::Unretained(blink::mainThreadIsolate())), |
2670 initial_cdm, media_surface_manager_); | 2699 initial_cdm, media_surface_manager_, media_observer); |
2671 | 2700 |
2672 #if defined(OS_ANDROID) | 2701 #if defined(OS_ANDROID) |
2673 if (!UseWebMediaPlayerImpl(url)) { | 2702 if (!UseWebMediaPlayerImpl(url)) { |
2674 return CreateAndroidWebMediaPlayer(client, encrypted_client, params); | 2703 return CreateAndroidWebMediaPlayer(client, encrypted_client, params); |
2675 } | 2704 } |
2676 #endif // defined(OS_ANDROID) | 2705 #endif // defined(OS_ANDROID) |
2677 | 2706 |
2678 #if defined(ENABLE_MOJO_RENDERER) | 2707 #if defined(ENABLE_MOJO_RENDERER) |
2679 std::unique_ptr<media::RendererFactory> media_renderer_factory( | 2708 std::unique_ptr<media::RendererFactory> media_renderer_factory( |
2680 new media::MojoRendererFactory( | 2709 new media::MojoRendererFactory( |
2681 base::Bind(&RenderThreadImpl::GetGpuFactories, | 2710 base::Bind(&RenderThreadImpl::GetGpuFactories, |
2682 base::Unretained(render_thread)), | 2711 base::Unretained(render_thread)), |
2683 GetMediaInterfaceProvider())); | 2712 GetMediaInterfaceProvider())); |
| 2713 #elif defined(ENABLE_MEDIA_REMOTING) |
| 2714 std::unique_ptr<media::RendererFactory> default_renderer_factory( |
| 2715 new media::DefaultRendererFactory( |
| 2716 media_log, GetDecoderFactory(), |
| 2717 base::Bind(&RenderThreadImpl::GetGpuFactories, |
| 2718 base::Unretained(render_thread)))); |
| 2719 media::RemotingController* remoting_controller_ptr = |
| 2720 remoting_controller.get(); |
| 2721 std::unique_ptr<media::RendererFactory> media_renderer_factory( |
| 2722 new media::RemotingRendererFactory(std::move(default_renderer_factory), |
| 2723 std::move(remoting_controller))); |
2684 #else | 2724 #else |
2685 std::unique_ptr<media::RendererFactory> media_renderer_factory( | 2725 std::unique_ptr<media::RendererFactory> media_renderer_factory( |
2686 new media::DefaultRendererFactory( | 2726 new media::DefaultRendererFactory( |
2687 media_log, GetDecoderFactory(), | 2727 media_log, GetDecoderFactory(), |
2688 base::Bind(&RenderThreadImpl::GetGpuFactories, | 2728 base::Bind(&RenderThreadImpl::GetGpuFactories, |
2689 base::Unretained(render_thread)))); | 2729 base::Unretained(render_thread)))); |
2690 #endif // defined(ENABLE_MOJO_RENDERER) | 2730 #endif |
2691 | 2731 |
2692 if (!url_index_.get() || url_index_->frame() != frame_) | 2732 if (!url_index_.get() || url_index_->frame() != frame_) |
2693 url_index_.reset(new media::UrlIndex(frame_)); | 2733 url_index_.reset(new media::UrlIndex(frame_)); |
2694 | 2734 |
2695 // TODO(miu): In a soon-upcoming change, call GetRemoterFactory()->Create() to | |
2696 // allow the local media pipeline to receive notifications about when Media | |
2697 // Remoting can take place. Control logic in/around WebMediaPlayerImpl will | |
2698 // implement media.mojom.RemotingSource. http://crbug.com/643964 | |
2699 | |
2700 media::WebMediaPlayerImpl* media_player = new media::WebMediaPlayerImpl( | 2735 media::WebMediaPlayerImpl* media_player = new media::WebMediaPlayerImpl( |
2701 frame_, client, encrypted_client, | 2736 frame_, client, encrypted_client, |
2702 GetWebMediaPlayerDelegate()->AsWeakPtr(), | 2737 GetWebMediaPlayerDelegate()->AsWeakPtr(), |
2703 std::move(media_renderer_factory), url_index_, params); | 2738 std::move(media_renderer_factory), url_index_, params); |
2704 | 2739 |
2705 #if defined(OS_ANDROID) // WMPI_CAST | 2740 #if defined(OS_ANDROID) // WMPI_CAST |
2706 media_player->SetMediaPlayerManager(GetMediaPlayerManager()); | 2741 media_player->SetMediaPlayerManager(GetMediaPlayerManager()); |
2707 media_player->SetDeviceScaleFactor(render_view_->GetDeviceScaleFactor()); | 2742 media_player->SetDeviceScaleFactor(render_view_->GetDeviceScaleFactor()); |
2708 #endif | 2743 #endif // defined(OS_ANDROID) |
| 2744 |
| 2745 #if defined(ENABLE_MEDIA_REMOTING) |
| 2746 remoting_controller_ptr->SetSwitchRendererCallback(base::Bind( |
| 2747 &media::WebMediaPlayerImpl::ScheduleRestart, media_player->AsWeakPtr())); |
| 2748 #endif // defined(ENABLE_MEDIA_REMOTING) |
2709 | 2749 |
2710 return media_player; | 2750 return media_player; |
2711 } | 2751 } |
2712 | 2752 |
2713 blink::WebMediaSession* RenderFrameImpl::createMediaSession() { | 2753 blink::WebMediaSession* RenderFrameImpl::createMediaSession() { |
2714 #if defined(OS_ANDROID) | 2754 #if defined(OS_ANDROID) |
2715 return new WebMediaSessionAndroid(GetMediaSessionManager()); | 2755 return new WebMediaSessionAndroid(GetMediaSessionManager()); |
2716 #else | 2756 #else |
2717 return nullptr; | 2757 return nullptr; |
2718 #endif // defined(OS_ANDROID) | 2758 #endif // defined(OS_ANDROID) |
(...skipping 3711 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6430 // event target. Potentially a Pepper plugin will receive the event. | 6470 // event target. Potentially a Pepper plugin will receive the event. |
6431 // In order to tell whether a plugin gets the last mouse event and which it | 6471 // In order to tell whether a plugin gets the last mouse event and which it |
6432 // is, we set |pepper_last_mouse_event_target_| to null here. If a plugin gets | 6472 // is, we set |pepper_last_mouse_event_target_| to null here. If a plugin gets |
6433 // the event, it will notify us via DidReceiveMouseEvent() and set itself as | 6473 // the event, it will notify us via DidReceiveMouseEvent() and set itself as |
6434 // |pepper_last_mouse_event_target_|. | 6474 // |pepper_last_mouse_event_target_|. |
6435 pepper_last_mouse_event_target_ = nullptr; | 6475 pepper_last_mouse_event_target_ = nullptr; |
6436 #endif | 6476 #endif |
6437 } | 6477 } |
6438 | 6478 |
6439 } // namespace content | 6479 } // namespace content |
OLD | NEW |