player: Remove CreateInstance() from some player classes (youtube#9244)

These methods were useful back when thread management was a more manual
process and classes like PlayerWorker::CreateInstance() could return
nullptr and this had to trickle up the caller hierarchy.

This is no longer the case since PRs like youtube#9027 and youtube#8064, and the
constructors can be called directly now.

Fixed: 477798131

Author: rakuco

starboard/android/shared/player_create.cc

@@ -204,24 +204,14 @@ SbPlayer SbPlayerCreate(SbWindow /*window*/,
   handler->SetMaxVideoInputSize(
       starboard::GetMaxVideoInputSizeForCurrentThread());
   handler->SetVideoSurfaceView(starboard::GetSurfaceViewForCurrentThread());
-  SbPlayer player = starboard::SbPlayerPrivateImpl::CreateInstance(
+  auto player = std::make_unique<starboard::SbPlayerPrivateImpl>(
       audio_codec, video_codec, sample_deallocate_func, decoder_status_func,
       player_status_func, player_error_func, context, std::move(handler));
-
-  if (SbPlayerIsValid(player)) {
-    if (creation_param->output_mode != kSbPlayerOutputModeDecodeToTexture) {
-      // TODO: accomplish this through more direct means.
-      // Set the bounds to initialize the VideoSurfaceView. The initial values
-      // don't matter.
-      SbPlayerSetBounds(player, 0, 0, 0, 0, 0);
-    }
-    return player;
+  if (creation_param->output_mode != kSbPlayerOutputModeDecodeToTexture) {
+    // TODO: accomplish this through more direct means.
+    // Set the bounds to initialize the VideoSurfaceView. The initial values
+    // don't matter.
+    SbPlayerSetBounds(player.get(), 0, 0, 0, 0, 0);
   }
-
-  SB_LOG(ERROR)
-      << "Invalid player returned by SbPlayerPrivateImpl::CreateInstance().";
-  player_error_func(
-      kSbPlayerInvalid, context, kSbPlayerErrorDecode,
-      "Invalid player returned by SbPlayerPrivateImpl::CreateInstance()");
-  return kSbPlayerInvalid;
+  return player.release();
 }

starboard/shared/starboard/player/player_create.cc

@@ -206,14 +206,14 @@ SbPlayer SbPlayerCreate(SbWindow /*window*/,
       std::make_unique<starboard::FilterBasedPlayerWorkerHandler>(
           creation_param, provider);
 
-  SbPlayer player = starboard::SbPlayerPrivateImpl::CreateInstance(
+  auto player = std::make_unique<starboard::SbPlayerPrivateImpl>(
       audio_codec, video_codec, sample_deallocate_func, decoder_status_func,
       player_status_func, player_error_func, context, std::move(handler));
 
 #if SB_PLAYER_ENABLE_VIDEO_DUMPER
-  starboard::VideoDmpWriter::OnPlayerCreate(player, audio_codec, video_codec,
-                                            drm_system, &audio_stream_info);
+  starboard::VideoDmpWriter::OnPlayerCreate(
+      player.get(), audio_codec, video_codec, drm_system, &audio_stream_info);
 #endif  // SB_PLAYER_ENABLE_VIDEO_DUMPER
 
-  return player;
+  return player.release();
 }

starboard/shared/starboard/player/player_internal.cc

@@ -31,11 +31,6 @@
 namespace starboard {
 namespace {
 
-using std::placeholders::_1;
-using std::placeholders::_2;
-using std::placeholders::_3;
-using std::placeholders::_4;
-
 int64_t CalculateMediaTime(int64_t media_time,
                            int64_t media_time_update_time,
                            double playback_rate) {
@@ -58,40 +53,24 @@ SbPlayerPrivateImpl::SbPlayerPrivateImpl(
     std::unique_ptr<PlayerWorker::Handler> player_worker_handler)
     : sample_deallocate_func_(sample_deallocate_func),
       context_(context),
-      media_time_updated_at_(CurrentMonotonicTime()) {
-  worker_ = std::unique_ptr<PlayerWorker>(PlayerWorker::CreateInstance(
-      audio_codec, video_codec, std::move(player_worker_handler),
-      std::bind(&SbPlayerPrivateImpl::UpdateMediaInfo, this, _1, _2, _3, _4),
-      decoder_status_func, player_status_func, player_error_func, this,
-      context));
-
+      media_time_updated_at_(CurrentMonotonicTime()),
+      worker_(std::make_unique<PlayerWorker>(
+          audio_codec,
+          video_codec,
+          std::move(player_worker_handler),
+          [this](auto&&... args) {
+            UpdateMediaInfo(std::forward<decltype(args)>(args)...);
+          },
+          decoder_status_func,
+          player_status_func,
+          player_error_func,
+          /*player=*/this,
+          context)) {
   ++number_of_players_;
   SB_LOG(INFO) << "Creating SbPlayerPrivateImpl. There are "
                << number_of_players_ << " players.";
 }
 
-// static
-SbPlayerPrivate* SbPlayerPrivateImpl::CreateInstance(
-    SbMediaAudioCodec audio_codec,
-    SbMediaVideoCodec video_codec,
-    SbPlayerDeallocateSampleFunc sample_deallocate_func,
-    SbPlayerDecoderStatusFunc decoder_status_func,
-    SbPlayerStatusFunc player_status_func,
-    SbPlayerErrorFunc player_error_func,
-    void* context,
-    std::unique_ptr<PlayerWorker::Handler> player_worker_handler) {
-  SbPlayerPrivateImpl* ret = new SbPlayerPrivateImpl(
-      audio_codec, video_codec, sample_deallocate_func, decoder_status_func,
-      player_status_func, player_error_func, context,
-      std::move(player_worker_handler));
-
-  if (ret && ret->worker_) {
-    return ret;
-  }
-  delete ret;
-  return nullptr;
-}
-
 void SbPlayerPrivateImpl::Seek(int64_t seek_to_time, int ticket) {
   {
     std::lock_guard lock(mutex_);

starboard/shared/starboard/player/player_internal.h

@@ -62,7 +62,7 @@ namespace starboard {
 
 class SbPlayerPrivateImpl final : public SbPlayerPrivate {
  public:
-  static SbPlayerPrivate* CreateInstance(
+  SbPlayerPrivateImpl(
       SbMediaAudioCodec audio_codec,
       SbMediaVideoCodec video_codec,
       SbPlayerDeallocateSampleFunc sample_deallocate_func,
@@ -94,16 +94,6 @@ class SbPlayerPrivateImpl final : public SbPlayerPrivate {
   ~SbPlayerPrivateImpl() final;
 
  private:
-  SbPlayerPrivateImpl(
-      SbMediaAudioCodec audio_codec,
-      SbMediaVideoCodec video_codec,
-      SbPlayerDeallocateSampleFunc sample_deallocate_func,
-      SbPlayerDecoderStatusFunc decoder_status_func,
-      SbPlayerStatusFunc player_status_func,
-      SbPlayerErrorFunc player_error_func,
-      void* context,
-      std::unique_ptr<PlayerWorker::Handler> player_worker_handler);
-
   void UpdateMediaInfo(int64_t media_time,
                        int dropped_video_frames,
                        int ticket,
@@ -126,7 +116,7 @@ class SbPlayerPrivateImpl final : public SbPlayerPrivate {
   // we may extrapolate the media time in GetInfo().
   bool is_progressing_ = false;
 
-  std::unique_ptr<PlayerWorker> worker_;
+  const std::unique_ptr<PlayerWorker> worker_;
 
   std::mutex audio_configurations_mutex_;
   std::vector<SbMediaAudioConfiguration> audio_configurations_;

starboard/shared/starboard/player/player_worker.cc

@@ -42,22 +42,6 @@ DECLARE_INSTANCE_COUNTER(PlayerWorker)
 
 }  // namespace
 
-PlayerWorker* PlayerWorker::CreateInstance(
-    SbMediaAudioCodec audio_codec,
-    SbMediaVideoCodec video_codec,
-    std::unique_ptr<Handler> handler,
-    UpdateMediaInfoCB update_media_info_cb,
-    SbPlayerDecoderStatusFunc decoder_status_func,
-    SbPlayerStatusFunc player_status_func,
-    SbPlayerErrorFunc player_error_func,
-    SbPlayer player,
-    void* context) {
-  return new PlayerWorker(audio_codec, video_codec, std::move(handler),
-                          update_media_info_cb, decoder_status_func,
-                          player_status_func, player_error_func, player,
-                          context);
-}
-
 PlayerWorker::~PlayerWorker() {
   ON_INSTANCE_RELEASED(PlayerWorker);
 

starboard/shared/starboard/player/player_worker.h

@@ -109,19 +109,20 @@ class PlayerWorker {
     Handler& operator=(const Handler&) = delete;
   };
 
-  static PlayerWorker* CreateInstance(
-      SbMediaAudioCodec audio_codec,
-      SbMediaVideoCodec video_codec,
-      std::unique_ptr<Handler> handler,
-      UpdateMediaInfoCB update_media_info_cb,
-      SbPlayerDecoderStatusFunc decoder_status_func,
-      SbPlayerStatusFunc player_status_func,
-      SbPlayerErrorFunc player_error_func,
-      SbPlayer player,
-      void* context);
-
+  PlayerWorker(SbMediaAudioCodec audio_codec,
+               SbMediaVideoCodec video_codec,
+               std::unique_ptr<Handler> handler,
+               UpdateMediaInfoCB update_media_info_cb,
+               SbPlayerDecoderStatusFunc decoder_status_func,
+               SbPlayerStatusFunc player_status_func,
+               SbPlayerErrorFunc player_error_func,
+               SbPlayer player,
+               void* context);
   ~PlayerWorker();
 
+  PlayerWorker(const PlayerWorker&) = delete;
+  PlayerWorker& operator=(const PlayerWorker&) = delete;
+
   void Seek(int64_t seek_to_time, int ticket) {
     job_thread_->Schedule(
         [this, seek_to_time, ticket] { DoSeek(seek_to_time, ticket); });
@@ -173,19 +174,6 @@ class PlayerWorker {
   }
 
  private:
-  PlayerWorker(SbMediaAudioCodec audio_codec,
-               SbMediaVideoCodec video_codec,
-               std::unique_ptr<Handler> handler,
-               UpdateMediaInfoCB update_media_info_cb,
-               SbPlayerDecoderStatusFunc decoder_status_func,
-               SbPlayerStatusFunc player_status_func,
-               SbPlayerErrorFunc player_error_func,
-               SbPlayer player,
-               void* context);
-
-  PlayerWorker(const PlayerWorker&) = delete;
-  PlayerWorker& operator=(const PlayerWorker&) = delete;
-
   void UpdateMediaInfo(int64_t time, int dropped_video_frames, bool underflow);
 
   SbPlayerState player_state() const { return player_state_; }