Fix the loop behavior on android

content/renderer/media/android/webmediaplayer_android.cc

 // 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.
 
 #include "content/renderer/media/android/webmediaplayer_android.h"
 
 #include <limits>
 
 #include "base/android/build_info.h"
 #include "base/bind.h"
@@ skipping 125 matching lines @@
       stream_id_(0),
       is_playing_(false),
       needs_establish_peer_(true),
       has_size_info_(false),
       compositor_loop_(
           RenderThreadImpl::current()->compositor_message_loop_proxy()),
       stream_texture_factory_(factory),
       needs_external_surface_(false),
       has_valid_metadata_(false),
       video_frame_provider_client_(NULL),
-      pending_playback_(false),
       player_type_(MEDIA_PLAYER_TYPE_URL),
       is_remote_(false),
       media_log_(media_log),
       web_cdm_(NULL),
       allow_stored_credentials_(false),
       is_local_resource_(false),
       interpolator_(&default_tick_clock_),
       weak_factory_(this) {
   DCHECK(player_manager_);
   DCHECK(cdm_manager_);
@@ skipping 609 matching lines @@
 }
 
 void WebMediaPlayerAndroid::OnPlaybackComplete() {
   // When playback is about to finish, android media player often stops
   // at a time which is smaller than the duration. This makes webkit never
   // know that the playback has finished. To solve this, we set the
   // current time to media duration when OnPlaybackComplete() get called.
   interpolator_.SetBounds(duration_, duration_);
   client_->timeChanged();
 
-  // if the loop attribute is set, timeChanged() will update the current time
-  // to 0. It will perform a seek to 0. As the requests to the renderer
-  // process are sequential, the OnSeekComplete() will only occur
-  // once OnPlaybackComplete() is done. As the playback can only be executed
-  // upon completion of OnSeekComplete(), the request needs to be saved.
-  UpdatePlayingState(false);
+  // If the loop attribute is set, timeChanged() will update the current time
+  // to 0. It will perform a seek to 0. Issue a command to the player to start
+  // playing after seek completes.
   if (seeking_ && seek_time_ == base::TimeDelta())
-    pending_playback_ = true;
+    player_manager_->Start(player_id_);

[DaleCurtis, 2014/09/18 18:15:33]

Isn't the player already started?

[qinmin, 2014/09/18 18:21:21]

when android mediaplayer reaches the end, it will automatically pause. This is
to kick the player to play again.

[DaleCurtis, 2014/09/18 18:23:33]

Is it okay to do this before the seek completes?

 }
 
 void WebMediaPlayerAndroid::OnBufferingUpdate(int percentage) {
   buffered_[0].end = has_valid_metadata_ ? duration() * percentage / 100 : 0;
   did_loading_progress_ = true;
 }
 
 void WebMediaPlayerAndroid::OnSeekRequest(const base::TimeDelta& time_to_seek) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   client_->requestSeek(time_to_seek.InSecondsF());
 }
 
 void WebMediaPlayerAndroid::OnSeekComplete(
     const base::TimeDelta& current_time) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   seeking_ = false;
   if (pending_seek_) {
     pending_seek_ = false;
     seek(pending_seek_time_.InSecondsF());
     return;
   }
   interpolator_.SetBounds(current_time, current_time);
 
   UpdateReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
 
   client_->timeChanged();
-
-  if (pending_playback_) {
-    play();
-    pending_playback_ = false;
-  }
 }
 
 void WebMediaPlayerAndroid::OnMediaError(int error_type) {
   switch (error_type) {
     case MediaPlayerAndroid::MEDIA_ERROR_FORMAT:
       UpdateNetworkState(WebMediaPlayer::NetworkStateFormatError);
       break;
     case MediaPlayerAndroid::MEDIA_ERROR_DECODE:
       UpdateNetworkState(WebMediaPlayer::NetworkStateDecodeError);
       break;
@@ skipping 1009 matching lines @@
 
 bool WebMediaPlayerAndroid::IsHLSStream() const {
   std::string mime;
   GURL url = redirected_url_.is_empty() ? url_ : redirected_url_;
   if (!net::GetMimeTypeFromFile(base::FilePath(url.path()), &mime))
     return false;
   return !mime.compare("application/x-mpegurl");
 }
 
 }  // namespace content