Media Remoting: Draw remoting interstitial on poster image.

content/renderer/render_frame_impl.h

 // 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.
 
 #ifndef CONTENT_RENDERER_RENDER_FRAME_IMPL_H_
 #define CONTENT_RENDERER_RENDER_FRAME_IMPL_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 54 matching lines @@
 #include "url/gurl.h"
 
 #if defined(ENABLE_PLUGINS)
 #include "content/renderer/pepper/plugin_power_saver_helper.h"
 #endif
 
 #if defined(OS_ANDROID)
 #include "content/renderer/media/android/renderer_media_player_manager.h"
 #endif
 
+#if BUILDFLAG(ENABLE_MEDIA_REMOTING)
+#include "media/remoting/remoting_renderer_controller.h"
+#endif
+
 struct FrameMsg_PostMessage_Params;
 struct FrameMsg_SerializeAsMHTML_Params;
 struct FrameMsg_TextTrackSettings_Params;
 
 namespace blink {
 class InterfaceRegistry;
 class WebContentDecryptionModule;
 class WebPresentationClient;
 class WebPushClient;
 class WebSecurityOrigin;
 enum class WebCachePolicy;
 struct WebCompositionUnderline;
 struct WebContextMenuData;
 struct WebCursorInfo;
 struct WebFindOptions;
 }  // namespace blink
 
 namespace gfx {
 class Point;
 class Range;
 class Rect;
 }
 
 namespace media {
 class CdmFactory;
 class DecoderFactory;
 class MediaPermission;
-class RemotingRendererController;
 class RemotingSinkObserver;
 class RendererWebMediaPlayerDelegate;
 class SurfaceManager;
 class UrlIndex;
 class WebEncryptedMediaClientImpl;
 }  // namespace media
 
 namespace service_manager {
 class InterfaceRegistry;
 class InterfaceProvider;
 }
 
 namespace url {
 class Origin;
 }
 
 namespace content {
 
 class AssociatedInterfaceProviderImpl;
 class BlinkInterfaceRegistryImpl;
 class ChildFrameCompositingHelper;
 class CompositorDependencies;
 class DevToolsAgent;
 class DocumentState;
 class ExternalPopupMenu;
 class HistoryEntry;
+class ImageDownloaderImpl;
 class ManifestManager;
 class MediaInterfaceProvider;
 class MediaStreamDispatcher;
 class MediaStreamRendererFactory;
 class MediaPermissionDispatcher;
 class NavigationState;
 class PageState;
 class PepperPluginInstanceImpl;
 class PresentationDispatcher;
 class PushMessagingDispatcher;
@@ skipping 925 matching lines @@
                      const blink::WebRect& selection_rect,
                      bool final_status_update);
 
   void InitializeBlameContext(RenderFrameImpl* parent_frame);
 
 #if BUILDFLAG(ENABLE_MEDIA_REMOTING)
   // Creates the RemotingRendererController to control whether to switch to/from
   // media remoting from/to local playback.
   std::unique_ptr<media::RemotingRendererController>
   CreateRemotingRendererController();
+
+  // Called to download the poster image in given |url|. When done,
+  // PosterDownloaded() is called |cb| will be run.
+  void DownloadPoster(

[miu, 2016/11/29 22:56:08]

These methods bring specific functionality (downloading poster images) into
RenderFrameImpl, whose purpose is to own and glue a massive object graph
together. Therefore, these need to go somewhere else. See other comments...

[xjz, 2016/12/02 19:23:10]

Done.

+      const GURL& url,
+      const media::RemotingRendererController::PosterDownloadedCallback& cb);
+  void PosterDownloaded(
+      const media::RemotingRendererController::PosterDownloadedCallback& cb,
+      int32_t http_status_code,
+      const std::vector<SkBitmap>& images,
+      const std::vector<gfx::Size>& sizes);
 #endif
 
   // Stores the WebLocalFrame we are associated with.  This is null from the
   // constructor until BindToWebFrame is called, and it is null after
   // frameDetached is called until destruction (which is asynchronous in the
   // case of the main frame, but not subframes).
   blink::WebLocalFrame* frame_;
 
   // Boolean value indicating whether this RenderFrameImpl object is for the
   // main frame or not. It remains accurate during destruction, even when
@@ skipping 127 matching lines @@
   RendererMediaPlayerManager* media_player_manager_;
   RendererMediaSessionManager* media_session_manager_;
 #endif
 
   media::SurfaceManager* media_surface_manager_;
 
 #if BUILDFLAG(ENABLE_MEDIA_REMOTING)
   // Lazy-bound pointer to the RemoterFactory service in the browser
   // process. Always use the GetRemoterFactory() accessor instead of this.
   media::mojom::RemoterFactoryPtr remoter_factory_;
+
   // An observer for the remoting sink availability that is used by
   // media::RemotingCdmFactory to initialize media::RemotingSourceImpl. Created
   // in the constructor of RenderFrameImpl to make sure
   // media::RemotingSourceImpl be intialized with correct availability info.
   // Own by media::RemotingCdmFactory after it is created.
   std::unique_ptr<media::RemotingSinkObserver> remoting_sink_observer_;
+
+  // The downloader used to download poster image, lazily initialized.
+  std::unique_ptr<ImageDownloaderImpl> poster_image_downloader_;

[miu, 2016/11/29 22:56:08]

Looks like ImageDownloaderImpl deletes itself when its OnDestruct() method is
called. So, RenderFrameImpl should not own it.

[xjz, 2016/12/02 19:23:10]

Not applicable.

 #endif
 
   // The CDM and decoder factory attached to this frame, lazily initialized.
   std::unique_ptr<media::CdmFactory> cdm_factory_;
   std::unique_ptr<media::DecoderFactory> decoder_factory_;
 
   // Media resource cache, lazily initialized.
   linked_ptr<media::UrlIndex> url_index_;
 
   // The devtools agent for this frame; only created for main frame and
@@ skipping 104 matching lines @@
   bool browser_side_navigation_pending_ = false;
 
   base::WeakPtrFactory<RenderFrameImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderFrameImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_RENDER_FRAME_IMPL_H_