Sets the media element network state to idle until playback is requested.

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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
@@ skipping 261 matching lines @@
   url_ = url;
   GURL first_party_url = frame_->document().firstPartyForCookies();
   proxy_->Initialize(player_id_, url, source_type_, first_party_url);
   if (manager_->IsInFullscreen(frame_))
     proxy_->EnterFullscreen(player_id_);
 
   UpdateNetworkState(WebMediaPlayer::NetworkStateLoading);
   UpdateReadyState(WebMediaPlayer::ReadyStateHaveNothing);
 }
 
 void WebMediaPlayerAndroid::DidLoadMediaInfo(

[scherkus (not reviewing), 2013/09/13 16:04:47]

considering this is a callback, are we sure HTMLMediaElement won't call
WebMediaPlayerAndroid::play() until after this method runs and updates the
readystate?

otherwise we'll end up with a network state of idle while playing

[Jinsuk Kim, 2013/09/16 02:20:18]

Thanks for catching it. Changed to make sure it happens only when play() is not
started yet.

     MediaInfoLoader::Status status) {
   DCHECK(!media_source_delegate_);
   if (status == MediaInfoLoader::kFailed) {
     info_loader_.reset();
     UpdateNetworkState(WebMediaPlayer::NetworkStateNetworkError);
     return;
   }
 
   has_media_info_ = true;
   if (has_media_metadata_ &&
       ready_state_ != WebMediaPlayer::ReadyStateHaveEnoughData) {
     UpdateReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
     UpdateReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
   }
+  // Android doesn't start fetching resources until an implementation-defined
+  // event (e.g. playback request) occurs. Sets to the network state to IDLE.
+  UpdateNetworkState(WebMediaPlayer::NetworkStateIdle);

[qinmin, 2013/09/03 14:22:46]

this is an optional step in HTML5 spec, do we really need this? and this should
be done before CORS  fetch

[Jinsuk Kim, 2013/09/04 01:32:03]

Though optional, I see benefit in having this - it makes Clank handle the media
loading state same as desktop Chrome does. When tested with preload attr -
default/none/metadata/auto, this CL ensures both get same sorts of events and
reach the same networkState.

What I understand from the code flow is that the state gets set to loading
initially, and then set to idle only when it reaches the step getting metadata.
In case it fails the state will remain loading and stalled event will be fired. 

Not sure where this should be moved to address your comment. It seems that CORS
info is fetched by MediaInfoLoader which is initialized in
WebMediaPlayerAndroid::load(), but it is also in this method that the initial
state is set to loading as well. Any more hint as to where it should go?

[qinmin, 2013/09/04 14:10:12]

can you run all the layout test with content shell and make sure there is no
regressions? and also add a layout test to test the code path if there is no
such one available
On 2013/09/04 01:32:03, jindor wrote:

[Jinsuk Kim, 2013/09/13 05:50:06]

Ran the tests and confirmed there's no regression. 

Let me add the test for the new codepath in a follow-up CL which will go under
WebKit/LayoutTest.

 }
 
 void WebMediaPlayerAndroid::play() {
 #if defined(GOOGLE_TV)
   if (hasVideo() && needs_external_surface_ &&
       !manager_->IsInFullscreen(frame_)) {
     DCHECK(!needs_establish_peer_);
     proxy_->RequestExternalSurface(player_id_, last_computed_rect_);
   }
   if (audio_renderer_ && paused())
     audio_renderer_->Play();
 #endif
   if (hasVideo() && needs_establish_peer_)
     EstablishSurfaceTexturePeer();
 
   if (paused())
     proxy_->Start(player_id_);
   UpdatePlayingState(true);
+  UpdateNetworkState(WebMediaPlayer::NetworkStateLoading);
 }
 
 void WebMediaPlayerAndroid::pause() {
 #if defined(GOOGLE_TV)
   if (audio_renderer_ && !paused())
     audio_renderer_->Pause();
 #endif
   proxy_->Pause(player_id_);
   UpdatePlayingState(false);
 }
@@ skipping 853 matching lines @@
 
 void WebMediaPlayerAndroid::exitFullscreen() {
   proxy_->ExitFullscreen(player_id_);
 }
 
 bool WebMediaPlayerAndroid::canEnterFullscreen() const {
   return manager_->CanEnterFullscreen(frame_);
 }
 
 }  // namespace content