Enable media element for castanets

build/config/BUILD.gn

@@ -62,6 +62,7 @@ config("feature_flags") {
   defines = [ "V8_DEPRECATION_WARNINGS" ]
   if (enable_castanets) {
     defines += [ "CASTANETS" ]
+    defines += [ "VIDEO_HOLE" ]
   }
   if (dcheck_always_on) {
     defines += [ "DCHECK_ALWAYS_ON=1" ]

cc/layers/video_frame_provider.h

@@ -9,12 +9,23 @@
 #include "base/time/time.h"
 #include "cc/cc_export.h"
 
+#if defined(VIDEO_HOLE)
+namespace gfx {
+class Rect;
+}
+#endif
+
 namespace media {
 class VideoFrame;
 }
 
 namespace cc {
 
+#if defined(VIDEO_HOLE)
+using DrawableContentRectChangedCallback =
+    base::RepeatingCallback<void(gfx::Rect, bool)>;
+#endif
+
 // VideoFrameProvider and VideoFrameProvider::Client define the relationship by
 // which video frames are exchanged between a provider and client.
 //
@@ -93,6 +104,13 @@ class CC_EXPORT VideoFrameProvider {
   // frame missed its intended deadline.
   virtual void PutCurrentFrame() = 0;
 
+#if defined(VIDEO_HOLE)
+  virtual void SetDrawableContentRectChangedCallback(
+      DrawableContentRectChangedCallback cb) = 0;
+
+  // Notifies the client of video plane geometry to be use.
+  virtual void OnDrawableContentRectChanged(const gfx::Rect&) = 0;
+#endif
  protected:
   virtual ~VideoFrameProvider() {}
 };

cc/layers/video_frame_provider_client_impl.cc

@@ -89,6 +89,15 @@ void VideoFrameProviderClientImpl::PutCurrentFrame() {
   provider_->PutCurrentFrame();
   needs_put_current_frame_ = false;
 }
+#if defined(VIDEO_HOLE)
+void VideoFrameProviderClientImpl::OnDrawableContentRectChanged(
+    const gfx::Rect rect) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  if (provider_)
+    provider_->OnDrawableContentRectChanged(rect);
+}
+#endif
 
 void VideoFrameProviderClientImpl::ReleaseLock() {
   DCHECK(thread_checker_.CalledOnValidThread());

cc/layers/video_frame_provider_client_impl.h

@@ -58,6 +58,10 @@ class CC_EXPORT VideoFrameProviderClientImpl
   void DidReceiveFrame() override;
   bool IsDrivingFrameUpdates() const override;
 
+#if defined(VIDEO_HOLE)
+  void OnDrawableContentRectChanged(const gfx::Rect);
+#endif
+
   const VideoFrameProvider* get_provider_for_testing() const {
     return provider_;
   }

cc/layers/video_layer_impl.cc

@@ -157,6 +157,15 @@ void VideoLayerImpl::AppendQuads(viz::RenderPass* render_pass,
                         visible_layer_rect(), clip_rect(), is_clipped(),
                         contents_opaque(), draw_opacity(),
                         GetSortingContextId(), visible_quad_rect);
+
+#if defined(VIDEO_HOLE)
+  const gfx::Rect video_rect =
+      cc::MathUtil::MapEnclosingClippedRect(transform, gfx::Rect(rotated_size));
+  if (previous_visible_rect_ != video_rect) {
+    previous_visible_rect_ = video_rect;
+    provider_client_impl_->OnDrawableContentRectChanged(video_rect);
+  }
+#endif
 }
 
 void VideoLayerImpl::DidDraw(viz::ClientResourceProvider* resource_provider) {

cc/layers/video_layer_impl.h

@@ -13,6 +13,10 @@
 #include "components/viz/common/resources/release_callback.h"
 #include "media/base/video_rotation.h"
 
+#if defined(VIDEO_HOLE)
+#include "ui/gfx/geometry/rect.h"
+#endif
+
 namespace media {
 class VideoFrame;
 class VideoResourceUpdater;
@@ -56,6 +60,10 @@ class CC_EXPORT VideoLayerImpl : public LayerImpl {
 
   const char* LayerTypeAsString() const override;
 
+#if defined(VIDEO_HOLE)
+  gfx::Rect previous_visible_rect_;
+#endif
+
   scoped_refptr<VideoFrameProviderClientImpl> provider_client_impl_;
 
   scoped_refptr<media::VideoFrame> frame_;

content/browser/media/android/browser_media_player_manager.cc

@@ -121,6 +121,8 @@ BrowserMediaPlayerManager::CreateMediaPlayer(
       }
       return std::move(media_player_bridge);
     }
+    default:
+      break;
   }
 
   NOTREACHED();

content/common/BUILD.gn

@@ -395,6 +395,14 @@ source_set("common") {
     "//content/public/common:interfaces",
   ]
 
+  if (enable_castanets) {
+    sources += [
+      "media/castanets_media_param_traits.cc",
+      "media/castanets_media_param_traits.h",
+      "media/castanets_media_player_messages.h",
+    ]
+  }
+
   if (is_android && use_seccomp_bpf) {
     set_sources_assignment_filter([])
     sources += [

content/common/content_message_generator.h

@@ -125,3 +125,12 @@
 #error "Failed to include content/common/media/media_player_messages_android.h"
 #endif
 #endif  // defined(OS_ANDROID)
+
+#if defined(CASTANETS)
+#undef CONTENT_COMMON_MEDIA_CASTANETS_MEDIA_PLAYER_MESSAGES_H_
+#include "content/common/media/castanets_media_player_messages.h"
+#ifndef CONTENT_COMMON_MEDIA_CASTANETS_MEDIA_PLAYER_MESSAGES_H_
+#error \
+    "Failed to include content/common/media/castanets_media_player_messages.h"
+#endif
+#endif

content/common/media/castanets_media_param_traits.cc

@@ -0,0 +1,52 @@
+// Copyright 2019 Samsung Electronics Inc. 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/common/media/castanets_media_param_traits.h"
+
+#include "base/strings/stringprintf.h"
+#include "ipc/ipc_message_utils.h"
+
+namespace IPC {
+
+void ParamTraits<media::Ranges<base::TimeDelta>>::Write(
+    base::Pickle* pickle,
+    const media::Ranges<base::TimeDelta>& range) {
+  WriteParam(pickle, static_cast<int>(range.size()));
+  for (size_t i = 0; i < range.size(); ++i) {
+    WriteParam(pickle, range.start(i));
+    WriteParam(pickle, range.end(i));
+  }
+}
+
+bool ParamTraits<media::Ranges<base::TimeDelta>>::Read(
+    const base::Pickle* pickle,
+    base::PickleIterator* iter,
+    media::Ranges<base::TimeDelta>* range) {
+  int size = 0;
+
+  // ReadLength() checks for < 0 itself.
+  if (!iter->ReadLength(&size))
+    return false;
+  for (int i = 0; i < size; i++) {
+    base::TimeDelta start, end;
+    if (!ReadParam(pickle, iter, &start) || !ReadParam(pickle, iter, &end))
+      return false;
+    range->Add(start, end);
+  }
+  return true;
+}
+
+void ParamTraits<media::Ranges<base::TimeDelta>>::Log(
+    const media::Ranges<base::TimeDelta>& pickle,
+    std::string* str) {
+  str->append("TimeRanges:[");
+  for (size_t i = 0u; i < pickle.size(); ++i) {
+    str->append(base::StringPrintf("{%zu:{%lf,%lf}}, ", i,
+                                   pickle.start(i).InSecondsF(),
+                                   pickle.end(i).InSecondsF()));
+  }
+  str->append("]");
+}
+
+}  // namespace IPC

content/common/media/castanets_media_param_traits.h

@@ -0,0 +1,23 @@
+#ifndef CONTENT_COMMON_MEDIA_CASTANETS_MEDIA_PARAM_TRAITS_H_
+#define CONTENT_COMMON_MEDIA_CASTANETS_MEDIA_PARAM_TRAITS_H_
+
+#include "base/pickle.h"
+#include "content/common/content_export.h"
+#include "ipc/ipc_param_traits.h"
+#include "media/base/ranges.h"
+
+namespace IPC {
+
+template <>
+struct CONTENT_EXPORT ParamTraits<media::Ranges<base::TimeDelta>> {
+  typedef media::Ranges<base::TimeDelta> param_type;
+  static void Write(base::Pickle* pickle, const param_type& ptype);
+  static bool Read(const base::Pickle* pickle,
+                   base::PickleIterator* iter,
+                   param_type* ptype);
+  static void Log(const param_type& ptype, std::string* str);
+};
+
+}  // namespace IPC
+
+#endif  // CONTENT_COMMON_MEDIA_CASTANETS_MEDIA_PARAM_TRAITS_H_

content/common/media/castanets_media_player_init_config.h

@@ -0,0 +1,24 @@
+// Copyright 2019 Samsung Electronics Inc. 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_COMMON_MEDIA_CASTANETS_MEDIA_PLAYER_INIT_CONFIG_H_
+#define CONTENT_COMMON_MEDIA_CASTANETS_MEDIA_PLAYER_INIT_CONFIG_H_
+
+#include <string>
+#include "media/blink/renderer_media_player_interface.h"
+#include "url/gurl.h"
+
+namespace content {
+
+struct MediaPlayerInitConfig {
+  MediaPlayerHostMsg_Initialize_Type type;
+  GURL url;
+  std::string mime_type;
+  int demuxer_client_id;
+  bool has_encrypted_listener_or_cdm;
+};
+
+}  // namespace content
+
+#endif  // CONTENT_COMMON_MEDIA_CASTANETS_MEDIA_PLAYER_INIT_CONFIG_H_

content/common/media/castanets_media_player_messages.h

@@ -0,0 +1,148 @@
+// Copyright 2019 Samsung Electronics Inc. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// IPC messages for castanets player.
+#ifndef CONTENT_COMMON_MEDIA_CASTANETS_MEDIA_PLAYER_MESSAGES_H_
+#define CONTENT_COMMON_MEDIA_CASTANETS_MEDIA_PLAYER_MESSAGES_H_
+
+#include "content/common/media/castanets_media_param_traits.h"
+#include "content/common/media/castanets_media_player_init_config.h"
+#include "ipc/ipc_message_macros.h"
+#include "media/blink/renderer_media_player_interface.h"
+#include "ui/gfx/geometry/rect_f.h"
+
+#undef IPC_MESSAGE_EXPORT
+#define IPC_MESSAGE_EXPORT CONTENT_EXPORT
+#define IPC_MESSAGE_START MediaPlayerCastanetsMsgStart
+
+IPC_ENUM_TRAITS(blink::WebMediaPlayer::ReadyState)
+IPC_ENUM_TRAITS(blink::WebMediaPlayer::NetworkState)
+#if !defined(OS_ANDROID)
+IPC_ENUM_TRAITS(MediaPlayerHostMsg_Initialize_Type)
+#endif
+
+// Should be same as castanets player.
+IPC_STRUCT_TRAITS_BEGIN(content::MediaPlayerInitConfig)
+IPC_STRUCT_TRAITS_MEMBER(type)
+IPC_STRUCT_TRAITS_MEMBER(url)
+IPC_STRUCT_TRAITS_MEMBER(mime_type)
+IPC_STRUCT_TRAITS_MEMBER(demuxer_client_id)
+IPC_STRUCT_TRAITS_MEMBER(has_encrypted_listener_or_cdm)
+IPC_STRUCT_TRAITS_END()
+
+// TODO (sm.venugopal): Rename the IPCs.
+// Initialize Efl player.
+IPC_MESSAGE_ROUTED2(MediaPlayerEflHostMsg_Init,
+                    int /* player_id */,
+                    content::MediaPlayerInitConfig /* config */)
+
+// Requests the player to enter fullscreen.
+IPC_MESSAGE_ROUTED1(MediaPlayerEflHostMsg_EnteredFullscreen,
+                    int /* player_id */)
+
+// Requests the player to exit fullscreen.
+IPC_MESSAGE_ROUTED1(MediaPlayerEflHostMsg_ExitedFullscreen, int /* player_id */)
+
+// Deinitialize Gst player.
+IPC_MESSAGE_ROUTED1(MediaPlayerEflHostMsg_DeInit, int /* player_id */)
+
+// Start playback.
+IPC_MESSAGE_ROUTED1(MediaPlayerEflHostMsg_Play, int /* player_id */)
+
+// Pause playback.
+IPC_MESSAGE_ROUTED2(MediaPlayerEflHostMsg_Pause,
+                    int /* player_id */,
+                    bool /* is_media_related_action */)
+
+// Suspend media player.
+IPC_MESSAGE_ROUTED1(MediaPlayerEflHostMsg_Suspend, int /* player_id */)
+
+// Resume media player.
+IPC_MESSAGE_ROUTED1(MediaPlayerEflHostMsg_Resume, int /* player_id*/)
+
+// Player was activated by an user or an app.
+IPC_MESSAGE_ROUTED1(MediaPlayerEflHostMsg_Activate, int /* player_id*/)
+
+// Player should deactivate (ex. save power).
+IPC_MESSAGE_ROUTED1(MediaPlayerEflHostMsg_Deactivate, int /* player_id*/)
+
+// Set volume.
+IPC_MESSAGE_ROUTED2(MediaPlayerEflHostMsg_SetVolume,
+                    int /* player_id */,
+                    double /* volume */)
+
+// Set playback rate.
+IPC_MESSAGE_ROUTED2(MediaPlayerEflHostMsg_SetRate,
+                    int /* player_id */,
+                    double /* rate */)
+
+// Playback duration.
+IPC_MESSAGE_ROUTED2(MediaPlayerEflMsg_DurationChanged,
+                    int /* player_id */,
+                    base::TimeDelta /* time */)
+
+// Current  duration.
+IPC_MESSAGE_ROUTED2(MediaPlayerEflMsg_TimeUpdate,
+                    int /* player_id */,
+                    base::TimeDelta /* time */)
+
+// Pause state.
+IPC_MESSAGE_ROUTED2(MediaPlayerEflMsg_PauseStateChanged,
+                    int /* player_id */,
+                    bool /* state */)
+
+// Seek state.
+IPC_MESSAGE_ROUTED1(MediaPlayerEflMsg_OnSeekComplete, int /* player_id */)
+
+// Current buffer range.
+IPC_MESSAGE_ROUTED2(MediaPlayerEflMsg_BufferUpdate,
+                    int /* player_id */,
+                    int /* buffering_percentage */)
+
+// Playback completed.
+IPC_MESSAGE_ROUTED1(MediaPlayerEflMsg_TimeChanged, int /* player_id */)
+
+IPC_MESSAGE_ROUTED1(MediaPlayerEflMsg_PlayerDestroyed, int /* player_id */)
+
+// Ready state change.
+IPC_MESSAGE_ROUTED2(MediaPlayerEflMsg_ReadyStateChange,
+                    int /* player_id */,
+                    blink::WebMediaPlayer::ReadyState /* state */)
+
+// Network state change.
+IPC_MESSAGE_ROUTED2(MediaPlayerEflMsg_NetworkStateChange,
+                    int /* player_id */,
+                    blink::WebMediaPlayer::NetworkState /* state */)
+
+// Gst media data has changed.
+IPC_MESSAGE_ROUTED4(MediaPlayerEflMsg_MediaDataChanged,
+                    int /* player_id */,
+                    int /* width */,
+                    int /* height */,
+                    int /* media */)
+
+// Set geometry.
+IPC_MESSAGE_ROUTED2(MediaPlayerEflHostMsg_SetGeometry,
+                    int /* player_id */,
+                    gfx::RectF /* position and size */)
+// Seek.
+IPC_MESSAGE_ROUTED2(MediaPlayerEflHostMsg_Seek,
+                    int /* player_id */,
+                    base::TimeDelta /* time */)
+
+IPC_MESSAGE_ROUTED2(MediaPlayerEflMsg_SeekRequest,
+                    int /* player_id */,
+                    base::TimeDelta /* time_to_seek */)
+
+// Player has begun suspend procedure
+IPC_MESSAGE_ROUTED2(MediaPlayerEflMsg_PlayerSuspend,
+                    int /* player_id */,
+                    bool /* is_preempted */)
+
+// Player has resumed
+IPC_MESSAGE_ROUTED2(MediaPlayerEflMsg_PlayerResumed,
+                    int /* player_id */,
+                    bool /* is_preempted */)
+
+#endif  // CONTENT_COMMON_MEDIA_CASTANETS_MEDIA_PLAYER_MESSAGES_H_