Move android mediaplayer from render process to browser process.

webkit/media/android/webmediaplayer_android.cc

 // Copyright (c) 2012 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 "webkit/media/android/webmediaplayer_android.h"
 
-#include <string>
-
-#include "base/bind.h"
-#include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/logging.h"
-#include "base/utf_string_conversions.h"
 #include "media/base/android/media_player_bridge.h"
 #include "net/base/mime_util.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaPlayerClient.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebCookieJar.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebRect.h"
 #include "webkit/media/android/stream_texture_factory_android.h"
 #include "webkit/media/android/webmediaplayer_manager_android.h"
-#include "webkit/media/android/webmediaplayer_proxy_android.h"
 #include "webkit/media/webmediaplayer_util.h"
 #include "webkit/media/webvideoframe_impl.h"
 
-using WebKit::WebCanvas;
-using WebKit::WebMediaPlayerClient;
+static const uint32 kGLTextureExternalOES = 0x8D65;
+
 using WebKit::WebMediaPlayer;
-using WebKit::WebRect;
 using WebKit::WebSize;
 using WebKit::WebTimeRanges;
 using WebKit::WebURL;
 using WebKit::WebVideoFrame;
 using media::MediaPlayerBridge;
 using media::VideoFrame;
-using webkit_media::WebVideoFrameImpl;
-
-// TODO(qinmin): Figure out where we should define this more appropriately
-static const uint32 kGLTextureExternalOES = 0x8D65;
 
 namespace webkit_media {
 
-// Because we create the media player lazily on android, the duration of the
-// media is initially unknown to us. This makes the user unable to perform
-// seek. To solve this problem, we use a temporary duration of 100 seconds when
-// the duration is unknown. And we scale the seek position later when duration
-// is available.
-// TODO(qinmin): create a thread and use android MediaMetadataRetriever
-// class to extract the duration.
-static const float kTemporaryDuration = 100.0f;
-
-bool WebMediaPlayerAndroid::incognito_mode_ = false;
-
 WebMediaPlayerAndroid::WebMediaPlayerAndroid(
-    WebKit::WebFrame* frame,
-    WebMediaPlayerClient* client,
-    WebKit::WebCookieJar* cookie_jar,
-    webkit_media::WebMediaPlayerManagerAndroid* manager,
-    webkit_media::StreamTextureFactory* factory)
-    : frame_(frame),
-      client_(client),
+    WebKit::WebMediaPlayerClient* client,
+    WebMediaPlayerManagerAndroid* manager,
+    StreamTextureFactory* factory)
+    : client_(client),
       buffered_(1u),
       video_frame_(new WebVideoFrameImpl(VideoFrame::CreateEmptyFrame())),
       main_loop_(MessageLoop::current()),
-      proxy_(new WebMediaPlayerProxyAndroid(main_loop_->message_loop_proxy(),
-                                            AsWeakPtr())),
-      prepared_(false),
-      duration_(0),
       pending_seek_(0),
       seeking_(false),
-      playback_completed_(false),
       did_loading_progress_(false),
-      cookie_jar_(cookie_jar),
       manager_(manager),
-      pending_play_event_(false),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
-      texture_id_(0),
-      stream_id_(0),
+      is_playing_(false),
       needs_establish_peer_(true),
       stream_texture_factory_(factory) {
   main_loop_->AddDestructionObserver(this);
   if (manager_)
     player_id_ = manager_->RegisterMediaPlayer(this);
+
   if (stream_texture_factory_.get()) {
     stream_texture_proxy_.reset(stream_texture_factory_->CreateProxy());
     stream_id_ = stream_texture_factory_->CreateStreamTexture(&texture_id_);
   }
 }
 
 WebMediaPlayerAndroid::~WebMediaPlayerAndroid() {
-  if (manager_)
-    manager_->UnregisterMediaPlayer(player_id_);
+  Destroy();
 
   if (stream_id_)
     stream_texture_factory_->DestroyStreamTexture(texture_id_);
 
+  if (manager_)
+    manager_->UnregisterMediaPlayer(player_id_);
+
   if (main_loop_)
     main_loop_->RemoveDestructionObserver(this);
 }
 
-void WebMediaPlayerAndroid::InitIncognito(bool incognito_mode) {
-  incognito_mode_ = incognito_mode;
-}
-
 void WebMediaPlayerAndroid::load(const WebURL& url, CORSMode cors_mode) {
   if (cors_mode != CORSModeUnspecified)
     NOTIMPLEMENTED() << "No CORS support";
 
   url_ = url;
 
-  UpdateNetworkState(WebMediaPlayer::NetworkStateLoading);
-  UpdateReadyState(WebMediaPlayer::ReadyStateHaveNothing);
-
-  // Calling InitializeMediaPlayer() will cause android mediaplayer to start
-  // buffering and decoding the data. On mobile devices, this costs a lot of
-  // data usage and could even introduce performance issues. So we don't
-  // initialize the player unless it is a local file. We will start loading
-  // the media only when play/seek/fullsceen button is clicked.
-  if (url_.SchemeIs("file")) {
-    InitializeMediaPlayer();
-    return;
-  }
-
-  // TODO(qinmin): we need a method to calculate the duration of the media.
-  // Android does not provide any function to do that.
-  // Set the initial duration value to kTemporaryDuration so that user can
-  // touch the seek bar to perform seek. We will scale the seek position later
-  // when we got the actual duration.
-  duration_ = kTemporaryDuration;
-
-  // Pretend everything has been loaded so that webkit can
-  // still call play() and seek().
-  UpdateReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
-  UpdateReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
+  InitializeMediaPlayer(url_);
 }
 
 void WebMediaPlayerAndroid::cancelLoad() {
   NOTIMPLEMENTED();
 }
 
 void WebMediaPlayerAndroid::play() {
-  if (media_player_.get()) {
-    if (!prepared_)
-      pending_play_event_ = true;
-    else
-      PlayInternal();
-  } else {
-    pending_play_event_ = true;
-    InitializeMediaPlayer();
-  }
+  if (hasVideo() && needs_establish_peer_)
+    EstablishSurfaceTexturePeer();
+
+  PlayInternal();
+  is_playing_ = true;
 }
 
 void WebMediaPlayerAndroid::pause() {
-  if (media_player_.get()) {
-    if (!prepared_)
-      pending_play_event_ = false;
-    else
-      PauseInternal();
-  } else {
-    // We don't need to load media if pause() is called.
-    pending_play_event_ = false;
-  }
+  PauseInternal();
+  is_playing_ = false;
 }
 
 void WebMediaPlayerAndroid::seek(float seconds) {
-  // Record the time to seek when OnMediaPrepared() is called.
   pending_seek_ = seconds;
+  seeking_ = true;
 
-  // Reset |playback_completed_| so that we return the correct current time.
-  playback_completed_ = false;
-
-  if (media_player_.get()) {
-    if (prepared_)
-      SeekInternal(seconds);
-  } else {
-    InitializeMediaPlayer();
-  }
+  SeekInternal(ConvertSecondsToTimestamp(seconds));
 }
 
 bool WebMediaPlayerAndroid::supportsFullscreen() const {
   return true;
 }
 
 bool WebMediaPlayerAndroid::supportsSave() const {
   return false;
 }
 
 void WebMediaPlayerAndroid::setEndTime(float seconds) {
   // Deprecated.
   // TODO(qinmin): Remove this from WebKit::WebMediaPlayer as it is never used.
 }
 
 void WebMediaPlayerAndroid::setRate(float rate) {
   NOTIMPLEMENTED();
 }
 
 void WebMediaPlayerAndroid::setVolume(float volume) {
-  if (media_player_.get())
-    media_player_->SetVolume(volume, volume);
+  NOTIMPLEMENTED();
 }
 
 void WebMediaPlayerAndroid::setVisible(bool visible) {
   // Deprecated.
   // TODO(qinmin): Remove this from WebKit::WebMediaPlayer as it is never used.
 }
 
 bool WebMediaPlayerAndroid::totalBytesKnown() {
   NOTIMPLEMENTED();
   return false;
 }
 
 bool WebMediaPlayerAndroid::hasVideo() const {
+  // If we have obtained video size information before, use it.
+  if (!natural_size_.isEmpty())
+    return true;
+
   // TODO(qinmin): need a better method to determine whether the current media
   // content contains video. Android does not provide any function to do
   // this.
   // We don't know whether the current media content has video unless
   // the player is prepared. If the player is not prepared, we fall back
   // to the mime-type. There may be no mime-type on a redirect URL.
   // In that case, we conservatively assume it contains video so that
   // enterfullscreen call will not fail.
-  if (!prepared_) {
-    if (!url_.has_path())
-      return false;
-    std::string mime;
-    if(!net::GetMimeTypeFromFile(FilePath(url_.path()), &mime))
-      return true;
-    return mime.find("audio/") == std::string::npos;
-  }
-
-  return !natural_size_.isEmpty();
+  if (!url_.has_path())
+    return false;
+  std::string mime;
+  if(!net::GetMimeTypeFromFile(FilePath(url_.path()), &mime))
+    return true;
+  return mime.find("audio/") == std::string::npos;
 }
 
 bool WebMediaPlayerAndroid::hasAudio() const {
   // TODO(hclam): Query status of audio and return the actual value.
   return true;
 }
 
 bool WebMediaPlayerAndroid::paused() const {
-  if (!prepared_)
-    return !pending_play_event_;
-  return !media_player_->IsPlaying();
+  return !is_playing_;
 }
 
 bool WebMediaPlayerAndroid::seeking() const {
   return seeking_;
 }
 
 float WebMediaPlayerAndroid::duration() const {
-  return duration_;
+  return static_cast<float>(duration_.InSecondsF());
 }
 
 float WebMediaPlayerAndroid::currentTime() const {
   // If the player is pending for a seek, return the seek time.
-  if (!prepared_ || seeking())
+  if (seeking())
     return pending_seek_;
 
-  // 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.
-  // And return the greater of the two values so that the current
-  // time is most updated.
-  if (playback_completed_)
-    return duration();
-  return static_cast<float>(media_player_->GetCurrentTime().InSecondsF());
+  return GetCurrentTimeInternal();
 }
 
 int WebMediaPlayerAndroid::dataRate() const {
   // Deprecated.
   // TODO(qinmin): Remove this from WebKit::WebMediaPlayer as it is never used.
   return 0;
 }
 
 WebSize WebMediaPlayerAndroid::naturalSize() const {
   return natural_size_;
@@ skipping 21 matching lines @@
   did_loading_progress_ = false;
   return ret;
 }
 
 unsigned long long WebMediaPlayerAndroid::totalBytes() const {
   // Deprecated.
   // TODO(qinmin): Remove this from WebKit::WebMediaPlayer as it is never used.
   return 0;
 }
 
-void WebMediaPlayerAndroid::setSize(const WebSize& size) {
-  texture_size_ = size;
+void WebMediaPlayerAndroid::setSize(const WebKit::WebSize& size) {
 }
 
 void WebMediaPlayerAndroid::paint(WebKit::WebCanvas* canvas,
                                   const WebKit::WebRect& rect,
                                   uint8_t alpha) {
   NOTIMPLEMENTED();
 }
 
 bool WebMediaPlayerAndroid::hasSingleSecurityOrigin() const {
   return false;
 }
 
 bool WebMediaPlayerAndroid::didPassCORSAccessCheck() const {
   return false;
 }
 
-WebMediaPlayer::MovieLoadType
-    WebMediaPlayerAndroid::movieLoadType() const {
+WebMediaPlayer::MovieLoadType WebMediaPlayerAndroid::movieLoadType() const {
   // Deprecated.
   // TODO(qinmin): Remove this from WebKit::WebMediaPlayer as it is never used.
   return WebMediaPlayer::MovieLoadTypeUnknown;
 }
 
 float WebMediaPlayerAndroid::mediaTimeForTimeValue(float timeValue) const {
   return ConvertSecondsToTimestamp(timeValue).InSecondsF();
 }
 
 unsigned WebMediaPlayerAndroid::decodedFrameCount() const {
   NOTIMPLEMENTED();
   return 0;
 }
 
 unsigned WebMediaPlayerAndroid::droppedFrameCount() const {
   NOTIMPLEMENTED();
   return 0;
 }
 
 unsigned WebMediaPlayerAndroid::audioDecodedByteCount() const {
   NOTIMPLEMENTED();
   return 0;
 }
 
 unsigned WebMediaPlayerAndroid::videoDecodedByteCount() const {
   NOTIMPLEMENTED();
   return 0;
 }
 
-void WebMediaPlayerAndroid::OnMediaPrepared() {
-  if (!media_player_.get())
-    return;
-
-  prepared_ = true;
-
-  // Update the media duration first so that webkit will get the correct
-  // duration when UpdateReadyState is called.
-  float dur = duration_;
-  duration_ = media_player_->GetDuration().InSecondsF();
-
+void WebMediaPlayerAndroid::OnMediaPrepared(base::TimeDelta duration) {
   if (url_.SchemeIs("file"))
     UpdateNetworkState(WebMediaPlayer::NetworkStateLoaded);
 
   if (ready_state_ != WebMediaPlayer::ReadyStateHaveEnoughData) {
     UpdateReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
     UpdateReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
   } else {
     // If the status is already set to ReadyStateHaveEnoughData, set it again
     // to make sure that Videolayerchromium will get created.
     UpdateReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
   }
 
-  if (!url_.SchemeIs("file")) {
-    // In we have skipped loading, the duration was preset to
-    // kTemporaryDuration. We have to update webkit about the new duration.
-    if (duration_ != dur) {
-      // Scale the |pending_seek_| according to the new duration.
-      pending_seek_ = pending_seek_ * duration_ / kTemporaryDuration;
-      client_->durationChanged();
-    }
+  // In we have skipped loading, we have to update webkit about the new
+  // duration.
+  if (duration_ != duration) {
+    duration_ = duration;
+    client_->durationChanged();
   }
-
-  // If media player was recovered from a saved state, consume all the pending
-  // events.
-  seek(pending_seek_);
-
-  if (pending_play_event_)
-    PlayInternal();
-
-  pending_play_event_ = false;
 }
 
 void WebMediaPlayerAndroid::OnPlaybackComplete() {
-  // Set the current time equal to duration to let webkit know that play back
-  // is completed.
-  playback_completed_ = true;
+  // 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.
+  OnTimeUpdate(duration_);
   client_->timeChanged();
 }
 
 void WebMediaPlayerAndroid::OnBufferingUpdate(int percentage) {
   buffered_[0].end = duration() * percentage / 100;
   did_loading_progress_ = true;
 }
 
-void WebMediaPlayerAndroid::OnSeekComplete() {
+void WebMediaPlayerAndroid::OnSeekComplete(base::TimeDelta current_time) {
   seeking_ = false;
 
+  OnTimeUpdate(current_time);
+
   UpdateReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
 
   client_->timeChanged();
 }
 
 void WebMediaPlayerAndroid::OnMediaError(int error_type) {
   switch (error_type) {
     case MediaPlayerBridge::MEDIA_ERROR_UNKNOWN:
       // When playing an bogus URL or bad file we fire a MEDIA_ERROR_UNKNOWN.
       // As WebKit uses FormatError to indicate an error for bogus URL or bad
       // file we default a MEDIA_ERROR_UNKNOWN to NetworkStateFormatError.
       UpdateNetworkState(WebMediaPlayer::NetworkStateFormatError);
       break;
     case MediaPlayerBridge::MEDIA_ERROR_SERVER_DIED:
       // TODO(zhenghao): Media server died. In this case, the application must
       // release the MediaPlayer object and instantiate a new one.
       UpdateNetworkState(WebMediaPlayer::NetworkStateDecodeError);
       break;
     case MediaPlayerBridge::MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK:
       UpdateNetworkState(WebMediaPlayer::NetworkStateFormatError);
       break;
     case MediaPlayerBridge::MEDIA_ERROR_INVALID_CODE:
       break;
   }
   client_->repaint();
 }
 
-void WebMediaPlayerAndroid::OnMediaInfo(int info_type) {
-  NOTIMPLEMENTED();
-}
-
 void WebMediaPlayerAndroid::OnVideoSizeChanged(int width, int height) {
   if (natural_size_.width == width && natural_size_.height == height)
     return;
 
   natural_size_.width = width;
   natural_size_.height = height;
   if (texture_id_) {
     video_frame_.reset(new WebVideoFrameImpl(VideoFrame::WrapNativeTexture(
         texture_id_, kGLTextureExternalOES, natural_size_, natural_size_,
         base::TimeDelta(),
@@ skipping 10 matching lines @@
 void WebMediaPlayerAndroid::UpdateReadyState(
     WebMediaPlayer::ReadyState state) {
   ready_state_ = state;
   client_->readyStateChanged();
 }
 
 void WebMediaPlayerAndroid::ReleaseMediaResources() {
   // Pause the media player first.
   pause();
   client_->playbackStateChanged();
+  needs_establish_peer_ = true;
 
-  if (media_player_.get()) {
-    // Save the current media player status.
-    pending_seek_ = currentTime();
-    duration_ = duration();
-
-    media_player_.reset();
-    needs_establish_peer_ = true;
-  }
-  prepared_ = false;
-}
-
-bool WebMediaPlayerAndroid::IsInitialized() const {
-  return (media_player_ != NULL);
-}
-
-void WebMediaPlayerAndroid::InitializeMediaPlayer() {
-  CHECK(!media_player_.get());
-  prepared_ = false;
-  media_player_.reset(new MediaPlayerBridge());
-  media_player_->SetStayAwakeWhilePlaying();
-
-  std::string cookies;
-  if (cookie_jar_ != NULL) {
-    WebURL first_party_url(frame_->document().firstPartyForCookies());
-    cookies = UTF16ToUTF8(cookie_jar_->cookies(url_, first_party_url));
-  }
-  media_player_->SetDataSource(url_.spec(), cookies, incognito_mode_);
-
-  if (manager_)
-    manager_->RequestMediaResources(player_id_);
-
-  media_player_->Prepare(
-      base::Bind(&WebMediaPlayerProxyAndroid::MediaInfoCallback, proxy_),
-      base::Bind(&WebMediaPlayerProxyAndroid::MediaErrorCallback, proxy_),
-      base::Bind(&WebMediaPlayerProxyAndroid::VideoSizeChangedCallback, proxy_),
-      base::Bind(&WebMediaPlayerProxyAndroid::BufferingUpdateCallback, proxy_),
-      base::Bind(&WebMediaPlayerProxyAndroid::MediaPreparedCallback, proxy_));
-}
-
-void WebMediaPlayerAndroid::PlayInternal() {
-  CHECK(prepared_);
-
-  if (hasVideo() && stream_texture_factory_.get()) {
-    if (needs_establish_peer_) {
-      stream_texture_factory_->EstablishPeer(stream_id_, player_id_);
-      needs_establish_peer_ = false;
-    }
-  }
-
-  if (paused())
-    media_player_->Start(base::Bind(
-        &WebMediaPlayerProxyAndroid::PlaybackCompleteCallback, proxy_));
-}
-
-void WebMediaPlayerAndroid::PauseInternal() {
-  CHECK(prepared_);
-  media_player_->Pause();
-}
-
-void WebMediaPlayerAndroid::SeekInternal(float seconds) {
-  CHECK(prepared_);
-  seeking_ = true;
-  media_player_->SeekTo(ConvertSecondsToTimestamp(seconds), base::Bind(
-      &WebMediaPlayerProxyAndroid::SeekCompleteCallback, proxy_));
+  ReleaseResourcesInternal();
 }
 
 void WebMediaPlayerAndroid::WillDestroyCurrentMessageLoop() {
+  Destroy();
+
+  if (stream_id_) {
+    stream_texture_factory_->DestroyStreamTexture(texture_id_);
+    stream_id_ = 0;
+  }
+
+  video_frame_.reset(new WebVideoFrameImpl(VideoFrame::CreateEmptyFrame()));
+
+  if (manager_)
+    manager_->UnregisterMediaPlayer(player_id_);
+
   manager_ = NULL;
   main_loop_ = NULL;
 }
 
 WebVideoFrame* WebMediaPlayerAndroid::getCurrentFrame() {
-  if (!stream_texture_proxy_->IsInitialized() && stream_id_) {
+  if (stream_texture_proxy_.get() && !stream_texture_proxy_->IsInitialized()
+      && stream_id_) {
     stream_texture_proxy_->Initialize(
         stream_id_, video_frame_->width(), video_frame_->height());
   }
 
   return video_frame_.get();
 }
 
 void WebMediaPlayerAndroid::putCurrentFrame(
     WebVideoFrame* web_video_frame) {
 }
 
-// This gets called both on compositor and main thread.
 void WebMediaPlayerAndroid::setStreamTextureClient(
     WebKit::WebStreamTextureClient* client) {
   if (stream_texture_proxy_.get())
     stream_texture_proxy_->SetClient(client);
 }
 
+void WebMediaPlayerAndroid::EstablishSurfaceTexturePeer() {
+  if (stream_texture_factory_.get() && stream_id_)
+    stream_texture_factory_->EstablishPeer(stream_id_, player_id_);
+  needs_establish_peer_ = false;
+}
+
+void WebMediaPlayerAndroid::UpdatePlayingState(bool is_playing) {
+  is_playing_ = is_playing;
+}
+
 }  // namespace webkit_media