Replaces VideoLayer with a SurfaceLayer in WebMediaPlayerImpl

media/blink/webmediaplayer_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 MEDIA_BLINK_WEBMEDIAPLAYER_IMPL_H_
 #define MEDIA_BLINK_WEBMEDIAPLAYER_IMPL_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 26 matching lines @@
 #include "media/blink/multibuffer_data_source.h"
 #include "media/blink/video_frame_compositor.h"
 #include "media/blink/webmediaplayer_delegate.h"
 #include "media/blink/webmediaplayer_params.h"
 #include "media/blink/webmediaplayer_util.h"
 #include "media/filters/pipeline_controller.h"
 #include "media/renderers/skcanvas_video_renderer.h"
 #include "third_party/WebKit/public/platform/WebAudioSourceProvider.h"
 #include "third_party/WebKit/public/platform/WebContentDecryptionModuleResult.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayer.h"
+#include "third_party/WebKit/public/platform/WebSurfaceLayerBridgeObserver.h"
+#include "third_party/WebKit/public/platform/WebVideoSurfaceLayerBridge.h"
 #include "url/gurl.h"
 
 #if defined(OS_ANDROID)  // WMPI_CAST
 // Delete this file when WMPI_CAST is no longer needed.
 #include "media/blink/webmediaplayer_cast_android.h"
 #endif
 
 namespace blink {
 class WebLocalFrame;
 class WebMediaPlayerClient;
@@ skipping 25 matching lines @@
 class WebAudioSourceProviderImpl;
 class WebMediaPlayerDelegate;
 
 // The canonical implementation of blink::WebMediaPlayer that's backed by
 // Pipeline. Handles normal resource loading, Media Source, and
 // Encrypted Media.
 class MEDIA_BLINK_EXPORT WebMediaPlayerImpl
     : public NON_EXPORTED_BASE(blink::WebMediaPlayer),
       public NON_EXPORTED_BASE(WebMediaPlayerDelegate::Observer),
       public NON_EXPORTED_BASE(Pipeline::Client),
+      public NON_EXPORTED_BASE(blink::WebSurfaceLayerBridgeObserver),
       public MediaObserverClient,
       public base::SupportsWeakPtr<WebMediaPlayerImpl> {
  public:
   // Constructs a WebMediaPlayer implementation using Chromium's media stack.
   // |delegate| and |renderer_factory_selector| must not be null.
   WebMediaPlayerImpl(
       blink::WebLocalFrame* frame,
       blink::WebMediaPlayerClient* client,
       blink::WebMediaPlayerEncryptedMediaClient* encrypted_client,
       WebMediaPlayerDelegate* delegate,
@@ skipping 121 matching lines @@
   gfx::Size GetCanvasSize() const;
   void SetDeviceScaleFactor(float scale_factor);
   void SetUseFallbackPath(bool use_fallback_path);
   void SetPoster(const blink::WebURL& poster) override;
 #endif
 
   // MediaObserverClient implementation.
   void SwitchRenderer(bool is_rendered_remotely) override;
   void ActivateViewportIntersectionMonitoring(bool activate) override;
 
+  // WebSurfaceLayerBridgeObserver implementation.
+  void OnWebLayerReplaced() override;

[enne (OOO), 2017/06/26 18:35:58]

I think the only reason that CanvasSurfaceLayerBridge needs this is so that it
can inform the HTMLCanvasElement to then call
Element::SetNeedsCompositingUpdate().

However, I think HTMLMediaElement's SetWebLayer already has this covered:
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/core/html/HTML....

[liberato (no reviews please), 2017/06/26 22:39:30]

+1.  that's what i tried, badly, to say in my previous round of comments.  :)

[CJ, 2017/06/29 19:51:33]

This looks good, but what happens when we are updating the SurfaceInfo out of
sequence? Right now we are updating SurfaceInfo whenever the Surface is created,
which may or may not be after Metadata has loaded.

Perhaps we should call SetWebLayer from OnWebLayerReplaced. 

+
   // Called from WebMediaPlayerCast.
   // TODO(hubbe): WMPI_CAST make private.
   void OnPipelineSeeked(bool time_updated);
 
   // Distinct states that |delegate_| can be in. (Public for testing.)
   enum class DelegateState {
     GONE,
     PLAYING,
     PAUSED,
   };
@@ skipping 471 matching lines @@
   // Used to track loading progress, used by IsPrerollAttemptNeeded().
   // |preroll_attempt_pending_| indicates that the clock has been reset
   // (awaiting a resume to start), while |preroll_attempt_start_time_| tracks
   // when a preroll attempt began.
   bool preroll_attempt_pending_;
   base::TimeTicks preroll_attempt_start_time_;
 
   // Monitors the player events.
   base::WeakPtr<MediaObserver> observer_;
 
+  // Obtains and maintains SurfaceIds.
+  std::unique_ptr<blink::WebVideoSurfaceLayerBridge> bridge_;
+
   // The maximum video keyframe distance that allows triggering background
   // playback optimizations (non-MSE).
   base::TimeDelta max_keyframe_distance_to_disable_background_video_;
 
   // The maximum video keyframe distance that allows triggering background
   // playback optimizations (MSE).
   base::TimeDelta max_keyframe_distance_to_disable_background_video_mse_;
 
   // When MSE memory pressure based garbage collection is enabled, the
   // |enable_instant_source_buffer_gc| controls whether the GC is done
@@ skipping 55 matching lines @@
   OverlayInfo::RoutingToken overlay_routing_token_;
 
   OverlayInfo overlay_info_;
 
   DISALLOW_COPY_AND_ASSIGN(WebMediaPlayerImpl);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BLINK_WEBMEDIAPLAYER_IMPL_H_