[MM] CAPI port code refactor

This patch is for refactoring code of CAPI port for media element.

Reference: http://165.213.202.130/gerrit/#/c/72864/

Bug: http://web.sec.samsung.net/bugzilla/show_bug.cgi?id=13055
Reviewed by: SeungSeop Park (OOO July 15~17), Venugopal S M

Change-Id: I7f411f51fa045a3b03639e5f43cf561e5a0dae33
Signed-off-by: Umesh Kumar Patel <umeshk.patel@samsung.com>
Signed-off-by: jitu.patel <jitu.patel@samsung.com>

diff --git a/tizen_src/chromium_impl/media/base/tizen/media_player_bridge_capi.cc b/tizen_src/chromium_impl/media/base/tizen/media_player_bridge_capi.cc
index cb129a4..37bd777 100644 (file)
--- a/tizen_src/chromium_impl/media/base/tizen/media_player_bridge_capi.cc
+++ b/tizen_src/chromium_impl/media/base/tizen/media_player_bridge_capi.cc
@@ -5,53 +5,46 @@
 #include "media/base/tizen/media_player_bridge_capi.h"
 
 #include "base/basictypes.h"
-#include "base/command_line.h"
 #include "base/logging.h"
-#include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/string_util.h"
-#include "content/public/browser/browser_thread.h"
-#include "content/public/common/content_switches.h"
 #include "media/base/efl/media_player_manager_efl.h"
 #include "media/base/efl/media_player_util_efl.h"
 #include "ui/gfx/geometry/size.h"
 
-#if defined(OS_TIZEN_MOBILE)
-#include <device/power.h>
-#endif
-
 #if defined(TIZEN_MULTIMEDIA_PIXMAP_SUPPORT)
 #if defined(TIZEN_V_2_4)
 #include <player_internal.h>
 #elif defined(TIZEN_LEGACY_V_2_2_1)
 #include <player_product.h>
 #endif
-#endif //TIZEN_MULTIMEDIA_PIXMAP_SUPPORT
+#endif  // TIZEN_MULTIMEDIA_PIXMAP_SUPPORT
+
 namespace {
+
 // Update duration every 100ms.
 const int kDurationUpdateInterval = 100;
-}
 
-namespace media {
+enum PlayerState {
+  PLAYER_STATE_DELAYED_NULL,
+  PLAYER_STATE_DELAYED_PLAY,
+  PLAYER_STATE_DELAYED_PAUSE,
+};
+
 struct ErrorList {
   player_error_e error_code;
   std::string error_message;
 };
 
-// Modify this when new error information is added to |errorlist|.
-const int ERROR_MAX = 18;
-
-const struct ErrorList errorlist[ERROR_MAX] = {
+const struct ErrorList errorlist[] = {
     {PLAYER_ERROR_OUT_OF_MEMORY, "PLAYER_ERROR_OUT_OF_MEMORY"},
     {PLAYER_ERROR_INVALID_PARAMETER, "PLAYER_ERROR_INVALID_PARAMETER"},
     {PLAYER_ERROR_NO_SUCH_FILE, "PLAYER_ERROR_NO_SUCH_FILE"},
     {PLAYER_ERROR_INVALID_OPERATION, "PLAYER_ERROR_INVALID_OPERATION"},
     {PLAYER_ERROR_FILE_NO_SPACE_ON_DEVICE,
-    "PLAYER_ERROR_FILE_NO_SPACE_ON_DEVICE"},
-#if defined(OS_TIZEN_MOBILE)
+        "PLAYER_ERROR_FILE_NO_SPACE_ON_DEVICE"},
     {PLAYER_ERROR_FEATURE_NOT_SUPPORTED_ON_DEVICE,
-    "PLAYER_ERROR_FEATURE_NOT_SUPPORTED_ON_DEVICE"},
-#endif
+        "PLAYER_ERROR_FEATURE_NOT_SUPPORTED_ON_DEVICE"},
     {PLAYER_ERROR_SEEK_FAILED, "PLAYER_ERROR_SEEK_FAILED"},
     {PLAYER_ERROR_INVALID_STATE, "PLAYER_ERROR_INVALID_STATE"},
     {PLAYER_ERROR_NOT_SUPPORTED_FILE, "PLAYER_ERROR_NOT_SUPPORTED_FILE"},
@@ -65,20 +58,22 @@ const struct ErrorList errorlist[ERROR_MAX] = {
     {PLAYER_ERROR_DRM_NOT_PERMITTED, "PLAYER_ERROR_DRM_NOT_PERMITTED"},
     {PLAYER_ERROR_RESOURCE_LIMIT, "PLAYER_ERROR_RESOURCE_LIMIT"}};
 
-// Called by player_prepare_async()
-void player_prepared_cb(void* user_data) {
-  MediaPlayerBridgeCapi* player =
-    static_cast<MediaPlayerBridgeCapi*>(user_data);
+const int ERROR_MAX = sizeof(errorlist) / sizeof(errorlist[0]);
 
+// Called by player_prepare_async()
+static void PlayerPreparedCb(void* data) {
+  media::MediaPlayerBridgeCapi* player =
+      static_cast<media::MediaPlayerBridgeCapi*>(data);
   if (!player || player->IsPlayerDestructing())
     return;
 
-  player->OnCompletedPrepare();
+  player->OnPlayerPrepared();
 }
 
 #if defined(TIZEN_MULTIMEDIA_PIXMAP_SUPPORT)
-static Eina_Bool notify_damage_updated_cb(void* data, int type, void* event) {
-  MediaPlayerBridgeCapi* player = static_cast <MediaPlayerBridgeCapi*>(data);
+static Eina_Bool NotifyDamageUpdatedCb(void* data, int type, void* event) {
+  media::MediaPlayerBridgeCapi* player =
+      static_cast<media::MediaPlayerBridgeCapi*>(data);
   if (!player)
     return ECORE_CALLBACK_PASS_ON;
 
@@ -87,26 +82,26 @@ static Eina_Bool notify_damage_updated_cb(void* data, int type, void* event) {
 }
 
 // Called by player_set_x11_display_pixmap()
-unsigned int pixmap_buffer_ready_cb(void *user_data) {
-  MediaPlayerBridgeCapi* player =
-    static_cast<MediaPlayerBridgeCapi*>(user_data);
-
+static unsigned int PixmapBufferReadyCb(void* data) {
+  media::MediaPlayerBridgeCapi* player =
+      static_cast<media::MediaPlayerBridgeCapi*>(data);
   if (!player || player->IsPlayerDestructing())
     return -1;
 
   return player->GetPixmapID();
 }
 #else
-static void media_packet_decoded_cb(media_packet_h packet, void* data) {
+static void MediaPacketDecodedCb(media_packet_h packet, void* data) {
   if (!packet) {
     LOG(ERROR) << "media_packet handle is null";
     return;
   }
 
-  MediaPlayerBridgeCapi* player = static_cast<MediaPlayerBridgeCapi*>(data);
+  media::MediaPlayerBridgeCapi* player =
+      static_cast<media::MediaPlayerBridgeCapi*>(data);
   if (!player || player->IsPlayerDestructing()) {
     media_packet_destroy(packet);
-    LOG(ERROR) << "media_packet_decoded_cb - player handle is null";
+    LOG(ERROR) << "Player is NULL or destructing.";
     return;
   }
   player->OnMediaPacketUpdated(packet);
@@ -114,10 +109,9 @@ static void media_packet_decoded_cb(media_packet_h packet, void* data) {
 #endif
 
 // Called by player_set_completed_cb()
-void playback_complete_cb(void* user_data) {
-  MediaPlayerBridgeCapi* player =
-    static_cast<MediaPlayerBridgeCapi*>(user_data);
-
+static void PlaybackCompleteCb(void* data) {
+  media::MediaPlayerBridgeCapi* player =
+      static_cast<media::MediaPlayerBridgeCapi*>(data);
   if (!player)
     return;
 
@@ -125,10 +119,9 @@ void playback_complete_cb(void* user_data) {
 }
 
 // Called by player_set_play_position() / player_set_position()
-void seek_complete_cb(void* user_data) {
-  MediaPlayerBridgeCapi* player =
-    static_cast<MediaPlayerBridgeCapi*>(user_data);
-
+static void SeekCompletedCb(void* data) {
+  media::MediaPlayerBridgeCapi* player =
+      static_cast<media::MediaPlayerBridgeCapi*>(data);
   if (!player)
     return;
 
@@ -136,10 +129,9 @@ void seek_complete_cb(void* user_data) {
 }
 
 // Called by player_set_buffering_cb()
-void changed_buffering_status_cb(int percent, void *user_data) {
-  MediaPlayerBridgeCapi* player =
-    static_cast<MediaPlayerBridgeCapi*>(user_data);
-
+static void ChangedBufferingStatusCb(int percent, void* data) {
+  media::MediaPlayerBridgeCapi* player =
+      static_cast<media::MediaPlayerBridgeCapi*>(data);
   if (!player)
     return;
 
@@ -147,31 +139,34 @@ void changed_buffering_status_cb(int percent, void *user_data) {
 }
 
 // Called by player_set_error_cb()
-void error_cb(int error_code, void *user_data) {
-  MediaPlayerBridgeCapi* player =
-    static_cast<MediaPlayerBridgeCapi*>(user_data);
-
+static void ErrorCb(int error_code, void* data) {
+  media::MediaPlayerBridgeCapi* player =
+      static_cast<media::MediaPlayerBridgeCapi*>(data);
   if (!player)
     return;
 
-  player->OnHandleError(error_code, "error_cb");
+  player->OnHandleError(error_code, "ErrorCb");
 }
 
 // Called by player_set_interrupted_cb()
-void interrupt_cb(player_interrupted_code_e code, void *user_data) {
-  MediaPlayerBridgeCapi* player =
-    static_cast<MediaPlayerBridgeCapi*>(user_data);
-
+static void InterruptCb(player_interrupted_code_e code, void* data) {
+  media::MediaPlayerBridgeCapi* player =
+      static_cast<media::MediaPlayerBridgeCapi*>(data);
   if (!player)
     return;
 
   // FIMXE: Add interrupt handling
 }
 
+}  // namespace
+
+namespace media {
+
 //static
-MediaPlayerEfl* MediaPlayerEfl::CreatePlayer(
-    int player_id, const GURL& url, double volume,
-    MediaPlayerManager* manager, const std::string& user_agent) {
+MediaPlayerEfl* MediaPlayerEfl::CreatePlayer(int player_id, const GURL& url,
+                                             double volume,
+                                             MediaPlayerManager* manager,
+                                             const std::string& user_agent) {
   LOG(INFO) << "MediaElement is using |CAPI| to play media";
   return new MediaPlayerBridgeCapi(player_id, url, volume, manager, user_agent);
 }
@@ -184,16 +179,14 @@ MediaPlayerBridgeCapi::MediaPlayerBridgeCapi(
     const std::string& user_agent)
     : MediaPlayerEfl(player_id, manager_in),
 #if defined(TIZEN_MULTIMEDIA_PIXMAP_SUPPORT)
-      pixmap_id_(0),
       efl_pixmap_(0),
-      m_damage(0),
-      m_damageHandler(NULL),
+      damage_(0),
+      damage_handler_(NULL),
 #else
       previous_packet_(NULL),
 #endif
       main_loop_(base::MessageLoopProxy::current()),
       player_(NULL),
-      url_(url),
       media_type_(0),
       player_width_(0),
       player_height_(0),
@@ -201,73 +194,68 @@ MediaPlayerBridgeCapi::MediaPlayerBridgeCapi(
       is_end_reached_(false),
       is_file_url_(false),
       is_paused_(true),
-      is_pixmap_used_(true),
       is_seeking_(false),
       duration_(0),
       seek_duration_(0),
       playback_rate_(1.0),
-      delayed_player_state_(0) {
-  VLOG(1) << __FUNCTION__ << " : Player Id = " << GetPlayerId();
+      delayed_player_state_(PLAYER_STATE_DELAYED_NULL) {
   int ret = player_create(&player_);
-  if (ret == PLAYER_ERROR_NONE) {
-    VLOG(1) << __FUNCTION__ << " : Create Player Success.";
-    VLOG(1) << __FUNCTION__ << " : URL = " << url_.spec().c_str();
-    player_set_uri(player_, url_.spec().c_str());
-    player_set_sound_type(player_, SOUND_TYPE_MEDIA);
-    player_set_volume(player_, (float)volume, (float)volume);
-    if (player_set_streaming_user_agent(
-            player_,
-            user_agent.c_str(),
-            user_agent.length()) != PLAYER_ERROR_NONE)
-        LOG(ERROR) << "Unable to set streaming user agent.";
+  if (ret != PLAYER_ERROR_NONE) {
+    HandleError(ret, "player_create");
+    return;
+  }
+
+  if (url.SchemeIsFile())
+    is_file_url_ = true;
+
+  player_set_uri(player_, url.spec().c_str());
+  player_set_sound_type(player_, SOUND_TYPE_MEDIA);
+  player_set_volume(player_, static_cast<float>(volume),
+                    static_cast<float>(volume));
+  if (player_set_streaming_user_agent(
+          player_,
+          user_agent.c_str(),
+          user_agent.length()) != PLAYER_ERROR_NONE)
+      LOG(ERROR) << "Unable to set streaming user agent.";
 
 #if defined(TIZEN_MULTIMEDIA_PIXMAP_SUPPORT)
-    // Use Pixmap
-    ret = player_set_x11_display_pixmap(player_,
-        pixmap_buffer_ready_cb, this);
-    if (ret != PLAYER_ERROR_NONE) {
-      HandleError(ret, "player_set_x11_display_pixmap");
-      return;
-    }
+  ret = player_set_x11_display_pixmap(player_, PixmapBufferReadyCb, this);
+  if (ret != PLAYER_ERROR_NONE) {
+    HandleError(ret, "player_set_x11_display_pixmap");
+    return;
+  }
 #else
-    ret = player_set_media_packet_video_frame_decoded_cb(player_,
-        media_packet_decoded_cb, this);
-    if (ret != PLAYER_ERROR_NONE) {
-      HandleError(ret, "player_set_media_packet_video_frame_decoded_cb");
-      return;
-    }
+  ret = player_set_media_packet_video_frame_decoded_cb(
+            player_, MediaPacketDecodedCb, this);
+  if (ret != PLAYER_ERROR_NONE) {
+    HandleError(ret, "player_set_media_packet_video_frame_decoded_cb");
+    return;
+  }
 #endif
-    player_set_completed_cb(player_, playback_complete_cb, this);
-    player_set_buffering_cb(player_, changed_buffering_status_cb, this);
-    player_set_interrupted_cb(player_, interrupt_cb, this);
-    player_set_error_cb(player_, error_cb, this);
+
+  player_set_completed_cb(player_, PlaybackCompleteCb, this);
+  player_set_buffering_cb(player_, ChangedBufferingStatusCb, this);
+  player_set_interrupted_cb(player_, InterruptCb, this);
+  player_set_error_cb(player_, ErrorCb, this);
 
 #if defined(TIZEN_MULTIMEDIA_PIXMAP_SUPPORT)
 #if defined(TIZEN_LEGACY_V_2_2_1)
-    player_set_x11_display_visible (player_, true);
+  player_set_x11_display_visible (player_, true);
 #else
-    player_set_display_visible (player_, true);
+  player_set_display_visible (player_, true);
 #endif
 #endif
-    if(url_.SchemeIsFile())
-      is_file_url_ = true;
 
-    manager()->OnReadyStateChange(GetPlayerId(),
-        MediaPlayerEfl::ReadyStateHaveEnoughData);
-    manager()->OnNetworkStateChange(GetPlayerId(),
-        MediaPlayerEfl::NetworkStateLoaded);
-
-  } else {
-    HandleError(ret, "player_create");
-  }
+  manager()->OnReadyStateChange(GetPlayerId(),
+                                MediaPlayerEfl::ReadyStateHaveEnoughData);
+  manager()->OnNetworkStateChange(GetPlayerId(),
+                                  MediaPlayerEfl::NetworkStateLoading);
 }
 
 MediaPlayerBridgeCapi::~MediaPlayerBridgeCapi() {
-  VLOG(1) << __FUNCTION__ << " : Player Id = " << GetPlayerId();
 }
 
 void MediaPlayerBridgeCapi::Destroy() {
-  VLOG(1) << __FUNCTION__ << " : Player Id = " << GetPlayerId();
   if (IsPlayerDestructing())
     return;
   destructing_ = true;
@@ -282,13 +270,13 @@ void MediaPlayerBridgeCapi::Destroy() {
 #endif
   player_destroy(player_);
 #if defined(TIZEN_MULTIMEDIA_PIXMAP_SUPPORT)
-  if (m_damage) {
-    ecore_x_damage_free(m_damage);
-    m_damage = 0;
+  if (damage_) {
+    ecore_x_damage_free(damage_);
+    damage_ = 0;
   }
-  if (m_damageHandler) {
-    ecore_event_handler_del(m_damageHandler);
-    m_damageHandler = NULL;
+  if (damage_handler_) {
+    ecore_event_handler_del(damage_handler_);
+    damage_handler_ = NULL;
   }
   if (efl_pixmap_.get()) {
     efl_pixmap_ = NULL;
@@ -303,21 +291,20 @@ void MediaPlayerBridgeCapi::Destroy() {
 }
 
 void MediaPlayerBridgeCapi::Play() {
-  VLOG(1) << __FUNCTION__ << " : Player Id = " << GetPlayerId();
   if (GetPlayerState() == PLAYER_STATE_IDLE) {
-    if(delayed_player_state_ != 0) {
-      delayed_player_state_ = DELAYED_PLAYER_STATE_PLAY;
+    if (delayed_player_state_ != PLAYER_STATE_DELAYED_NULL) {
+      delayed_player_state_ = PLAYER_STATE_DELAYED_PLAY;
       return;
     }
-    delayed_player_state_ = DELAYED_PLAYER_STATE_PLAY;
-    int ret = player_prepare_async(player_, player_prepared_cb, this);
+    delayed_player_state_ = PLAYER_STATE_DELAYED_PLAY;
+    int ret = player_prepare_async(player_, PlayerPreparedCb, this);
     if (ret != PLAYER_ERROR_NONE)
       HandleError(ret, "player_prepare_async");
     return;
   }
 
   if (is_seeking_) {
-    delayed_player_state_ = DELAYED_PLAYER_STATE_PLAY;
+    delayed_player_state_ = PLAYER_STATE_DELAYED_PLAY;
     return;
   }
 
@@ -327,13 +314,12 @@ void MediaPlayerBridgeCapi::Play() {
   }
 
   if (player_start(player_) != PLAYER_ERROR_NONE) {
-    LOG(ERROR) <<"Play() -> |player_start| failed";
+    LOG(ERROR) << "|player_start| failed";
     return;
   }
 
 #if defined(OS_TIZEN_MOBILE)
-  if (device_power_request_lock(POWER_LOCK_DISPLAY, 0) != DEVICE_ERROR_NONE)
-    LOG(ERROR) <<"Play() -> |device_power_request_lock| failed";
+  WakeUpDisplayAndAcquireDisplayLock();
 #endif
   StartCurrentTimeUpdateTimer();
   if (!is_file_url_)
@@ -342,22 +328,21 @@ void MediaPlayerBridgeCapi::Play() {
   is_end_reached_ = false;
 }
 
-void MediaPlayerBridgeCapi::Pause(bool is_media_related_action) {
-  VLOG(1) << __FUNCTION__ << " : Player Id = " << GetPlayerId();
+void MediaPlayerBridgeCapi::Pause(bool /* is_media_related_action */) {
   if (GetPlayerState() == PLAYER_STATE_IDLE) {
-    if(delayed_player_state_ != 0) {
-      delayed_player_state_ = DELAYED_PLAYER_STATE_PAUSE;
+    if (delayed_player_state_ != PLAYER_STATE_DELAYED_NULL) {
+      delayed_player_state_ = PLAYER_STATE_DELAYED_PAUSE;
       return;
     }
-    delayed_player_state_ = DELAYED_PLAYER_STATE_PAUSE;
-    int ret = player_prepare_async(player_, player_prepared_cb, this);
+    delayed_player_state_ = PLAYER_STATE_DELAYED_PAUSE;
+    int ret = player_prepare_async(player_, PlayerPreparedCb, this);
     if (ret != PLAYER_ERROR_NONE)
       HandleError(ret, "player_prepare_async");
     return;
   }
 
   if (player_pause(player_) != PLAYER_ERROR_NONE) {
-    LOG(ERROR) << "Pause() -> |player_pause| failed";
+    LOG(ERROR) << "|player_pause| failed";
     return;
   }
 
@@ -365,8 +350,7 @@ void MediaPlayerBridgeCapi::Pause(bool is_media_related_action) {
     StartBufferingUpdateTimer();
 
 #if defined(OS_TIZEN_MOBILE)
-  if (device_power_release_lock(POWER_LOCK_DISPLAY) != DEVICE_ERROR_NONE)
-    LOG(ERROR) << "|device_power_release_lock| request failed";
+  ReleaseDisplayLock();
 #endif
 
   StopCurrentTimeUpdateTimer();
@@ -374,7 +358,6 @@ void MediaPlayerBridgeCapi::Pause(bool is_media_related_action) {
 }
 
 void MediaPlayerBridgeCapi::SetRate(double rate) {
-  VLOG(1) << __FUNCTION__ << " : Player Id = " << GetPlayerId();
   if (playback_rate_ == rate)
     return;
 
@@ -384,13 +367,15 @@ void MediaPlayerBridgeCapi::SetRate(double rate) {
     return;
   }
 
-  // Fixme: SetRate is always failing
-  if (player_set_playback_rate(player_, (float)rate) != PLAYER_ERROR_NONE)
-    LOG(ERROR) <<"|player_set_playback_rate|failed";
-  else {
+  // FIXME: SetRate is always failing.
+  if (player_set_playback_rate(
+          player_,
+          static_cast<float>(rate)) != PLAYER_ERROR_NONE) {
+    LOG(ERROR) << "|player_set_playback_rate| failed";
+  } else {
     // If previous rate was zero and requested rate is non-zero, change the
-    // playback rate and call play
-    if(playback_rate_ == 0.0 && rate != 0.0) {
+    // playback rate and call play.
+    if (playback_rate_ == 0.0) {
       playback_rate_ = rate;
       Play();
     } else {
@@ -400,16 +385,17 @@ void MediaPlayerBridgeCapi::SetRate(double rate) {
 }
 
 void MediaPlayerBridgeCapi::Seek(const double time) {
-  VLOG(1) << __FUNCTION__ << " : Player Id = " << GetPlayerId();
 #if defined(TIZEN_LEGACY_V_2_2_1)
-  int err = player_set_position(player_,
-      ConvertSecondsToMilliSeconds(time), seek_complete_cb, this);
+  int err = player_set_position(player_, ConvertSecondsToMilliSeconds(time),
+                                SeekCompletedCb, this);
 #else
   int err = player_set_play_position(player_,
-      ConvertSecondsToMilliSeconds(time), true, seek_complete_cb, this);
+                                     ConvertSecondsToMilliSeconds(time),
+                                     true, SeekCompletedCb, this);
 #endif
+
   if (err != PLAYER_ERROR_NONE) {
-    LOG(ERROR) <<"|player_set_playback_rate|failed";
+    LOG(ERROR) << "|player_set_playback_rate| failed";
     manager()->OnTimeUpdate(GetPlayerId(), GetCurrentTime());
     manager()->OnTimeChanged(GetPlayerId());
     return;
@@ -432,9 +418,6 @@ void MediaPlayerBridgeCapi::Release() {
 }
 
 void MediaPlayerBridgeCapi::SetVolume(double volume) {
-  VLOG(1) << __FUNCTION__ << " : Player Id = " << GetPlayerId()
-          << " : Volume : " << volume;
-
   if (GetPlayerState() == PLAYER_STATE_NONE)
     return;
 
@@ -448,23 +431,19 @@ void MediaPlayerBridgeCapi::UpdateMediaType() {
   int audio_bit_rate = 0;
   media_type_ = 0;
 
-  int err = player_get_audio_stream_info(player_,
-                &sample_rate, &channel, &audio_bit_rate);
+  int err = player_get_audio_stream_info(player_, &sample_rate, &channel,
+                                         &audio_bit_rate);
   if (err != PLAYER_ERROR_NONE) {
     HandleError(err, "player_get_audio_stream_info");
     return;
   }
 
-  VLOG(1) << "Audio Information: sample_rate = " << sample_rate
-          << " , channel = " << channel
-          << " , audio_bit_rate = " << audio_bit_rate;
-
   // Audio stream is present if sample rate is valid.
   if (sample_rate > 0)
     media_type_ |= MEDIA_AUDIO_MASK;
 
 // FIXME : player_get_video_size() always returns zero if using media_packet.
-// If the platform issue is resolved, Please Remove it.
+// Remove it once the platform issue is resolved.
 #if defined(TIZEN_MULTIMEDIA_PIXMAP_SUPPORT)
   err = player_get_video_size(player_, &player_width_, &player_height_);
   if (err != PLAYER_ERROR_NONE) {
@@ -478,20 +457,21 @@ void MediaPlayerBridgeCapi::UpdateMediaType() {
     media_type_ |= MEDIA_VIDEO_MASK;
 
   manager()->OnMediaDataChange(GetPlayerId(), video_format_, player_height_,
-      player_width_, media_type_);
+                               player_width_, media_type_);
 }
 
 void MediaPlayerBridgeCapi::UpdateDuration() {
   int duration = 0;
   player_get_duration(player_, &duration);
+  duration = ConvertMilliSecondsToSeconds(duration);
 
-  if (duration_ != ConvertMilliSecondsToSeconds(duration)) {
-    duration_ = ConvertMilliSecondsToSeconds(duration);
+  if (duration_ != duration) {
+    duration_ = duration;
     manager()->OnDurationChange(GetPlayerId(), duration_);
   }
 
   // No need to buffer 'local file'. Update buffered percentage.
-  if(is_file_url_) {
+  if (is_file_url_) {
     std::vector<media::MediaPlayerEfl::TimeRanges> buffer_range;
     media::MediaPlayerEfl::TimeRanges range;
     range.start = 0;
@@ -547,19 +527,21 @@ void MediaPlayerBridgeCapi::OnBufferingUpdateTimerFired() {
   if (IsPlayerDestructing())
     return;
 
-  int start, current;
-  if (player_get_streaming_download_progress(player_,
-      &start, &current) == PLAYER_ERROR_NONE) {
+  int start = 0, current = 0;
+  if (player_get_streaming_download_progress(
+          player_, &start, &current) == PLAYER_ERROR_NONE) {
     if (current == 100) {
       StopBufferingUpdateTimer();
       manager()->OnNetworkStateChange(GetPlayerId(),
-          MediaPlayerEfl::NetworkStateLoaded);
+                                      MediaPlayerEfl::NetworkStateLoaded);
     }
     std::vector<media::MediaPlayerEfl::TimeRanges> buffer_range;
     media::MediaPlayerEfl::TimeRanges range;
     range.start = 0;
-    range.end = static_cast<double>(current) * duration_ / 100
-        * base::Time::kMicrosecondsPerSecond;
+
+    // Get current% of |duration_| and convert into microseconds
+    range.end =
+        ((duration_ * current) / 100) * base::Time::kMicrosecondsPerSecond;
     buffer_range.push_back(range);
     manager()->OnBufferUpdate(GetPlayerId(), buffer_range);
   }
@@ -585,11 +567,9 @@ void MediaPlayerBridgeCapi::OnTimeChanged() {
 }
 
 void MediaPlayerBridgeCapi::PlaybackCompleteUpdate() {
-  VLOG(1) << __FUNCTION__ << " : Player Id = " << GetPlayerId();
   is_end_reached_ = true;
 #if defined(OS_TIZEN_MOBILE)
-  if (device_power_release_lock(POWER_LOCK_DISPLAY) != DEVICE_ERROR_NONE)
-    LOG(ERROR) << "|device_power_release_lock| request failed";
+  ReleaseDisplayLock();
 #endif
 
   StopCurrentTimeUpdateTimer();
@@ -604,16 +584,14 @@ void MediaPlayerBridgeCapi::SeekCompleteUpdate() {
   if (!is_file_url_)
     StartBufferingUpdateTimer();
 
-  if (delayed_player_state_ == DELAYED_PLAYER_STATE_PLAY) {
-    ExecuteDelayedPlayerState();
-  }
+  ExecuteDelayedPlayerState();
 }
 
 void MediaPlayerBridgeCapi::UpdateSeekState(bool state) {
   is_seeking_ = state;
 }
 
-void MediaPlayerBridgeCapi::CompletedPrepare() {
+void MediaPlayerBridgeCapi::PlayerPrepared() {
   UpdateMediaType();
   if (media_type_ == 0)
     return;
@@ -622,9 +600,9 @@ void MediaPlayerBridgeCapi::CompletedPrepare() {
   SetPixmap();
 #endif
   manager()->OnReadyStateChange(GetPlayerId(),
-      MediaPlayerEfl::ReadyStateHaveEnoughData);
+                                MediaPlayerEfl::ReadyStateHaveEnoughData);
   manager()->OnNetworkStateChange(GetPlayerId(),
-      MediaPlayerEfl::NetworkStateLoaded);
+                                  MediaPlayerEfl::NetworkStateLoaded);
 
   ExecuteDelayedPlayerState();
 }
@@ -638,33 +616,25 @@ void MediaPlayerBridgeCapi::PlatformSurfaceUpdated() {
   player_get_play_position(player_, &postion);
 #endif
   base::TimeDelta timestamp = base::TimeDelta::FromMilliseconds(postion);
-  manager()->OnPlatformSurfaceUpdated(GetPlayerId(), pixmap_id_, timestamp);
+  manager()->OnPlatformSurfaceUpdated(GetPlayerId(), efl_pixmap_->GetId(),
+                                      timestamp);
 }
 
 void MediaPlayerBridgeCapi::SetPixmap() {
-  VLOG(1) << __FUNCTION__ << " : Player Id = " << GetPlayerId();
-
   if ((media_type_ & MEDIA_VIDEO_MASK) && !efl_pixmap_.get()) {
-    efl_pixmap_ = gfx::EflPixmap::Create(gfx::EflPixmap::SURFACE,
-        gfx::Size(player_width_, player_height_));
+    efl_pixmap_ = gfx::EflPixmap::Create(
+        gfx::EflPixmap::SURFACE, gfx::Size(player_width_, player_height_));
     if (!efl_pixmap_.get()) {
-      HandleError(0, " PixmapSurfaceTizen::create");
-      return ;
+      HandleError(0, "PixmapSurfaceTizen::create");
+      return;
     }
-    is_pixmap_used_ = true;
-    pixmap_id_ = efl_pixmap_->GetId();
 
     //Register to get notification from ecore for damage updates.
-    m_damage = ecore_x_damage_new(pixmap_id_,
-        ECORE_X_DAMAGE_REPORT_RAW_RECTANGLES);
-    m_damageHandler = ecore_event_handler_add(ECORE_X_EVENT_DAMAGE_NOTIFY,
-        notify_damage_updated_cb, this);
+    damage_ = ecore_x_damage_new(efl_pixmap_->GetId(),
+                                 ECORE_X_DAMAGE_REPORT_RAW_RECTANGLES);
+    damage_handler_ = ecore_event_handler_add(ECORE_X_EVENT_DAMAGE_NOTIFY,
+                                              NotifyDamageUpdatedCb, this);
   }
-
-  manager()->OnReadyStateChange(GetPlayerId(),
-      MediaPlayerEfl::ReadyStateHaveEnoughData);
-  manager()->OnNetworkStateChange(GetPlayerId(),
-      MediaPlayerEfl::NetworkStateLoaded);
 }
 #else
 void MediaPlayerBridgeCapi::MediaPacketUpdated(media_packet_h packet) {
@@ -674,7 +644,6 @@ void MediaPlayerBridgeCapi::MediaPacketUpdated(media_packet_h packet) {
 
   tbm_surface_h surface;
   media_packet_get_tbm_surface(packet, &surface);
-  VLOG(1) << "surface : " << surface;
   SendFrame(surface);
   previous_packet_ = packet;
 }
@@ -686,14 +655,14 @@ void MediaPlayerBridgeCapi::SendFrame(tbm_surface_h surface) {
     LOG(ERROR) << "tbm_surface_get_info() failed";
     return;
   }
-  VLOG(1) << "size : " << suf_info.size << " , format : " << suf_info.format
-          << "width : " << suf_info.width << ", height :" << suf_info.height;
+
+  // CAPI doesn't give out resolution change notification.
   if (player_height_ != suf_info.height || player_width_ != suf_info.width) {
     player_height_ = suf_info.height;
     player_width_ = suf_info.width;
     video_format_ = suf_info.format;
     manager()->OnMediaDataChange(GetPlayerId(), video_format_, player_height_,
-        player_width_, media_type_);
+                                 player_width_, media_type_);
   }
 
   base::SharedMemory shared_memory;
@@ -704,8 +673,8 @@ void MediaPlayerBridgeCapi::SendFrame(tbm_surface_h surface) {
   }
 
   base::SharedMemoryHandle foreign_memory_handle;
-  if (!shared_memory.ShareToProcess(
-      base::Process::Current().Handle(), &foreign_memory_handle)) {
+  if (!shared_memory.ShareToProcess(base::Process::Current().Handle(),
+                                    &foreign_memory_handle)) {
     LOG(ERROR) << "Shared Memory handle could not be obtained";
     return;
   }
@@ -718,97 +687,86 @@ void MediaPlayerBridgeCapi::SendFrame(tbm_surface_h surface) {
 #endif
   base::TimeDelta timestamp = base::TimeDelta::FromMilliseconds(position);
   memcpy(shared_memory.memory(), suf_info.planes[0].ptr, shared_memory_size);
-  manager()->OnNewFrameAvailable(
-      GetPlayerId(), foreign_memory_handle, shared_memory_size, timestamp);
+  manager()->OnNewFrameAvailable(GetPlayerId(), foreign_memory_handle,
+                                 shared_memory_size, timestamp);
 }
 #endif
 
 void MediaPlayerBridgeCapi::HandleBufferingStatus(int percent) {
-  if (IsPlayerDestructing())
+  if (IsPlayerDestructing() || is_paused_ || is_seeking_)
     return;
 
-  if (percent == 100 && !is_paused_ && !is_seeking_) {
-    if (GetPlayerState() == PLAYER_STATE_PAUSED) {
-      VLOG(1) << __FUNCTION__ << " : Player Id = " << GetPlayerId()
-        << " : Playing MediaPlayer as buffer reached 100%";
-      if (player_start(player_) != PLAYER_ERROR_NONE) {
-        LOG(ERROR) << "HandleBufferingStatus:player_start failed";
-        return;
-      }
-      StartCurrentTimeUpdateTimer();
-
-      if (!is_file_url_)
-        StartBufferingUpdateTimer();
-
-      manager()->OnReadyStateChange(GetPlayerId(),
-          MediaPlayerEfl::ReadyStateHaveEnoughData);
-      manager()->OnNetworkStateChange(GetPlayerId(),
-          MediaPlayerEfl::NetworkStateLoading);
+  if (percent == 100) {
+    if (GetPlayerState() != PLAYER_STATE_PAUSED)
+      return;
+    if (player_start(player_) != PLAYER_ERROR_NONE) {
+      LOG(ERROR) << "|player_start| failed";
       return;
     }
-  }
+    StartCurrentTimeUpdateTimer();
 
-  if (percent != 100 && !is_paused_ && !is_seeking_) {
-    if (GetPlayerState() == PLAYER_STATE_PLAYING) {
-      VLOG(1) << __FUNCTION__ << " : Player Id = " << GetPlayerId()
-        << " : Pausing MediaPlayer as buffer is < 100%";
-      if (player_pause(player_) != PLAYER_ERROR_NONE) {
-        LOG(ERROR) << "HandleBufferingStatus:player_pause failed";
-        return;
-      }
-      StopCurrentTimeUpdateTimer();
-      manager()->OnReadyStateChange(GetPlayerId(),
-          MediaPlayerEfl::ReadyStateHaveCurrentData);
-      manager()->OnNetworkStateChange(GetPlayerId(),
-          MediaPlayerEfl::NetworkStateLoading);
+    if (!is_file_url_)
+      StartBufferingUpdateTimer();
+
+    manager()->OnReadyStateChange(GetPlayerId(),
+                                  MediaPlayerEfl::ReadyStateHaveEnoughData);
+  } else {
+    if (GetPlayerState() != PLAYER_STATE_PLAYING)
+      return;
+    if (player_pause(player_) != PLAYER_ERROR_NONE) {
+      LOG(ERROR) << "|player_pause| failed";
+      return;
     }
+
+    StopCurrentTimeUpdateTimer();
+    manager()->OnReadyStateChange(GetPlayerId(),
+                                  MediaPlayerEfl::ReadyStateHaveCurrentData);
   }
+  manager()->OnNetworkStateChange(GetPlayerId(),
+                                  MediaPlayerEfl::NetworkStateLoading);
 }
 
 // Helper method which prints errors occured while calling CAPI api's.
 void MediaPlayerBridgeCapi::HandleError(int err, char const* from) {
-  int index;
-  for (index = 0; index < ERROR_MAX; index++) {
+  int index = 0;
+  for (index = 0; index < ERROR_MAX; ++index) {
     if (errorlist[index].error_code == err) {
-      LOG(ERROR) << "Stoping playback of media due to Error code : "<<err
-          <<" Error message : "<<errorlist[index].error_message
-          <<" from " << from;
+      LOG(ERROR) << "Stoping playback of media due to Error code : " << err
+                 << " Error message : " << errorlist[index].error_message
+                 << " from " << from;
       break;
     }
   }
 
   if (index == ERROR_MAX)
     LOG(ERROR) << "Stoping playback of media due to Unknown error : "
-        <<err <<" from " << from;
+               << err << " from " << from;
 
   StopBufferingUpdateTimer();
   StopCurrentTimeUpdateTimer();
   manager()->OnNetworkStateChange(GetPlayerId(),
-      MediaPlayerEfl::NetworkStateDecodeError);
+                                  MediaPlayerEfl::NetworkStateDecodeError);
 
-#ifdef OS_TIZEN_MOBILE
-  if (device_power_release_lock(POWER_LOCK_DISPLAY) != DEVICE_ERROR_NONE)
-    LOG(ERROR) << "|device_power_release_lock| request failed";
+#if defined(OS_TIZEN_MOBILE)
+  ReleaseDisplayLock();
 #endif
 }
 
 player_state_e MediaPlayerBridgeCapi::GetPlayerState() {
-  player_state_e state;
-  player_get_state(player_,&state);
+  player_state_e state = PLAYER_STATE_NONE;
+  player_get_state(player_, &state);
   return state;
 }
 
 void MediaPlayerBridgeCapi::ExecuteDelayedPlayerState() {
   switch (delayed_player_state_) {
-    case DELAYED_PLAYER_STATE_PLAY :
-      VLOG(1) << "Executing the delayed play command";
+    case PLAYER_STATE_DELAYED_PLAY :
       Play();
       break;
-    case DELAYED_PLAYER_STATE_PAUSE :
-      VLOG(1) << "Executing the delayed pause command";
+    case PLAYER_STATE_DELAYED_PAUSE :
       Pause(false);
       break;
-    default :
+    default:
       break;
   }
 }
@@ -817,8 +775,7 @@ void MediaPlayerBridgeCapi::ExecuteDelayedPlayerState() {
 void MediaPlayerBridgeCapi::OnMediaPacketUpdated(media_packet_h packet) {
   main_loop_->PostTask(
       FROM_HERE, base::Bind(&MediaPlayerBridgeCapi::MediaPacketUpdated,
-                            base::Unretained(this),
-                            packet));
+                            base::Unretained(this), packet));
 }
 #endif
 
@@ -834,25 +791,22 @@ void MediaPlayerBridgeCapi::OnSeekCompleteUpdate() {
                             base::Unretained(this)));
 }
 
-void MediaPlayerBridgeCapi::OnCompletedPrepare() {
+void MediaPlayerBridgeCapi::OnPlayerPrepared() {
   main_loop_->PostTask(
-      FROM_HERE, base::Bind(&MediaPlayerBridgeCapi::CompletedPrepare,
+      FROM_HERE, base::Bind(&MediaPlayerBridgeCapi::PlayerPrepared,
                             base::Unretained(this)));
 }
 
 void MediaPlayerBridgeCapi::OnHandleBufferingStatus(int percent) {
   main_loop_->PostTask(
       FROM_HERE, base::Bind(&MediaPlayerBridgeCapi::HandleBufferingStatus,
-                            base::Unretained(this),
-                            percent));
+                            base::Unretained(this), percent));
 }
 
 void MediaPlayerBridgeCapi::OnHandleError(int error_code, const char *msg) {
   main_loop_->PostTask(
       FROM_HERE, base::Bind(&MediaPlayerBridgeCapi::HandleError,
-                            base::Unretained(this),
-                            error_code,
-                            msg));
+                            base::Unretained(this), error_code, msg));
 }
 
 }  // namespace media

diff --git a/tizen_src/chromium_impl/media/base/tizen/media_player_bridge_capi.h b/tizen_src/chromium_impl/media/base/tizen/media_player_bridge_capi.h
index 2bc79f6..6273338 100644 (file)
--- a/tizen_src/chromium_impl/media/base/tizen/media_player_bridge_capi.h
+++ b/tizen_src/chromium_impl/media/base/tizen/media_player_bridge_capi.h
@@ -30,27 +30,25 @@ namespace media {
 class MEDIA_EXPORT MediaPlayerBridgeCapi
     : public MediaPlayerEfl {
  public:
-  MediaPlayerBridgeCapi(int player_id,
-      const GURL& url,
-      double volume,
-      MediaPlayerManager* manager,
-      const std::string& user_agent);
-  virtual ~MediaPlayerBridgeCapi();
+  MediaPlayerBridgeCapi(int player_id, const GURL& url, double volume,
+                        MediaPlayerManager* manager,
+                        const std::string& user_agent);
+  ~MediaPlayerBridgeCapi() override;
 
   // MediaPlayerTizen implementation.
-  virtual void Destroy() override;
-  virtual void Play() override;
-  virtual void Pause(bool is_media_related_action) override;
-  virtual void SetRate(double rate) override;
-  virtual void Seek(const double time) override;
-  virtual void SetVolume(double volume) override;
-  virtual double GetCurrentTime() override;
+  void Destroy() override;
+  void Play() override;
+  void Pause(bool is_media_related_action) override;
+  void SetRate(double rate) override;
+  void Seek(const double time) override;
+  void SetVolume(double volume) override;
+  double GetCurrentTime() override;
 
   void ExecuteDelayedPlayerState();
 
 #if defined(TIZEN_MULTIMEDIA_PIXMAP_SUPPORT)
   void SetPixmap();
-  int GetPixmapID() const {return pixmap_id_;}
+  int GetPixmapID() const {return efl_pixmap_->GetId();}
   void PlatformSurfaceUpdated();
 #else
   void OnMediaPacketUpdated(media_packet_h packet);
@@ -59,12 +57,12 @@ class MEDIA_EXPORT MediaPlayerBridgeCapi
 
   void OnPlaybackCompleteUpdate();
   void OnSeekCompleteUpdate();
-  void OnCompletedPrepare();
+  void OnPlayerPrepared();
   void OnHandleBufferingStatus(int percent);
   void OnHandleError(int ret, char const* from);
 
  protected:
-  virtual void Release();
+  void Release() override;
 
  private:
   // |duration_update_timer_| related
@@ -87,17 +85,16 @@ class MEDIA_EXPORT MediaPlayerBridgeCapi
 #endif
   void PlaybackCompleteUpdate();
   void SeekCompleteUpdate();
-  void CompletedPrepare();
+  void PlayerPrepared();
   void HandleBufferingStatus(int percent);
   void HandleError(int ret, char const* from);
   player_state_e GetPlayerState();
 
  private:
 #if defined(TIZEN_MULTIMEDIA_PIXMAP_SUPPORT)
-  int pixmap_id_;
   scoped_refptr<gfx::EflPixmap> efl_pixmap_;
-  Ecore_X_Damage m_damage;
-  Ecore_Event_Handler* m_damageHandler;
+  Ecore_X_Damage damage_;
+  Ecore_Event_Handler* damage_handler;
 #else
   media_packet_h previous_packet_;
 #endif
@@ -105,27 +102,23 @@ class MEDIA_EXPORT MediaPlayerBridgeCapi
   const scoped_refptr<base::MessageLoopProxy> main_loop_;
 
   player_h player_;
-  GURL url_;
 
   int media_type_;
   unsigned int player_width_;
   unsigned int player_height_;
   unsigned int video_format_;
 
-  bool is_download_finished_;
   bool is_end_reached_;
   bool is_file_url_;
   bool is_paused_;
-  bool is_pixmap_used_;
   bool is_seeking_;
+  bool is_play_pending_;
 
   double duration_;
   double seek_duration_;
   double playback_rate_;
 
   int delayed_player_state_;
-  const static int DELAYED_PLAYER_STATE_PLAY  = 1;
-  const static int DELAYED_PLAYER_STATE_PAUSE = 2;
 
   base::RepeatingTimer<MediaPlayerBridgeCapi> current_time_update_timer_;
   base::RepeatingTimer<MediaPlayerBridgeCapi> buffering_update_timer_;
@@ -135,5 +128,4 @@ class MEDIA_EXPORT MediaPlayerBridgeCapi
 
 }  // namespace media
 
-#endif  // MEDIA_TIZEN_MEDIA_PLAYER_BRIDGE_CAPI_H_
-
+#endif  // MEDIA_BASE_TIZEN_MEDIA_PLAYER_BRIDGE_CAPI_H_