Refactoring ContentVideoViewContextDelegate.java

content/browser/android/media_player_manager_impl.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 "content/browser/android/media_player_manager_impl.h"
 
+#include "content/browser/android/content_view_core_impl.h"
 #include "content/browser/android/media_resource_getter_impl.h"
 #include "content/browser/web_contents/web_contents_view_android.h"
 #include "content/common/media/media_player_messages_android.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/storage_partition.h"
+#include "content/public/browser/web_contents.h"
 
 using media::MediaPlayerAndroid;
 
 // Threshold on the number of media players per renderer before we start
 // attempting to release inactive media players.
 static const int kMediaPlayerThreshold = 1;
 
 namespace media {
 
 static MediaPlayerManager::FactoryFunction g_factory_function = NULL;
@@ skipping 12 matching lines @@
   return new content::MediaPlayerManagerImpl(render_view_host);
 }
 
 }  // namespace media
 
 namespace content {
 
 MediaPlayerManagerImpl::MediaPlayerManagerImpl(
     RenderViewHost* render_view_host)
     : RenderViewHostObserver(render_view_host),
-      video_view_(this),
       fullscreen_player_id_(-1),
       web_contents_(WebContents::FromRenderViewHost(render_view_host)) {
 }
 
 MediaPlayerManagerImpl::~MediaPlayerManagerImpl() {}
 
 bool MediaPlayerManagerImpl::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(MediaPlayerManagerImpl, msg)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_EnterFullscreen, OnEnterFullscreen)
@@ skipping 50 matching lines @@
   Send(new MediaPlayerMsg_DidExitFullscreen(
       routing_id(), fullscreen_player_id_));
   MediaPlayerAndroid* player = GetFullscreenPlayer();
   fullscreen_player_id_ = -1;
   if (!player)
     return;
   if (release_media_player)
     player->Release();
   else
     player->SetVideoSurface(gfx::ScopedJavaSurface());
+  video_view_.reset();
 }
 
 void MediaPlayerManagerImpl::SetVideoSurface(gfx::ScopedJavaSurface surface) {
   MediaPlayerAndroid* player = GetFullscreenPlayer();
   if (player) {
     player->SetVideoSurface(surface.Pass());
     Send(new MediaPlayerMsg_DidEnterFullscreen(
         routing_id(), player->player_id()));
   }
 }
@@ skipping 38 matching lines @@
 
 void MediaPlayerManagerImpl::OnPause(int player_id) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (player)
     player->Pause();
 }
 
 void MediaPlayerManagerImpl::OnEnterFullscreen(int player_id) {
   DCHECK_EQ(fullscreen_player_id_, -1);
 
-  fullscreen_player_id_ = player_id;
-  video_view_.CreateContentVideoView();
+  if (video_view_.get()) {
+    fullscreen_player_id_ = player_id;
+    video_view_->OpenVideo();
+  } else if (!ContentVideoView::HasContentVideoView()) {
+    // In Android WebView, two ContentViewCores could both try to enter
+    // fullscreen video, we just ignore the second one.
+    fullscreen_player_id_ = player_id;
+    WebContents* web_contents =
+        WebContents::FromRenderViewHost(render_view_host());
+    ContentViewCoreImpl* content_view_core_impl =
+        ContentViewCoreImpl::FromWebContents(web_contents);
+    video_view_.reset(new ContentVideoView(content_view_core_impl->GetContext(),
+        content_view_core_impl->GetContentVideoViewClient(), this));
+  }
 }
 
 void MediaPlayerManagerImpl::OnExitFullscreen(int player_id) {
   if (fullscreen_player_id_ == player_id) {
     MediaPlayerAndroid* player = GetPlayer(player_id);
     if (player)
       player->SetVideoSurface(gfx::ScopedJavaSurface());
-    video_view_.DestroyContentVideoView();
     fullscreen_player_id_ = -1;
+    video_view_->OnExitFullscreen();
+    video_view_.reset();
   }
 }
 
 void MediaPlayerManagerImpl::OnReleaseResources(int player_id) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
   // Don't release the fullscreen player when tab visibility changes,
   // it will be released when user hit the back/home button or when
   // OnDestroyPlayer is called.
   if (player && player_id != fullscreen_player_id_)
     player->Release();
 }
 
 void MediaPlayerManagerImpl::OnDestroyPlayer(int player_id) {
   RemovePlayer(player_id);
   if (fullscreen_player_id_ == player_id)
     fullscreen_player_id_ = -1;
 }
 
 void MediaPlayerManagerImpl::DestroyAllMediaPlayers() {
   players_.clear();
   if (fullscreen_player_id_ != -1) {
-    video_view_.DestroyContentVideoView();
+    video_view_.reset();
     fullscreen_player_id_ = -1;
   }
 }
 
 void MediaPlayerManagerImpl::OnDemuxerReady(
     int player_id,
     const media::MediaPlayerHostMsg_DemuxerReady_Params& params) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (player)
     player->DemuxerReady(params);
@@ skipping 54 matching lines @@
 MediaPlayerAndroid* MediaPlayerManagerImpl::GetFullscreenPlayer() {
   return GetPlayer(fullscreen_player_id_);
 }
 
 void MediaPlayerManagerImpl::OnMediaMetadataChanged(
     int player_id, base::TimeDelta duration, int width, int height,
     bool success) {
   Send(new MediaPlayerMsg_MediaMetadataChanged(
       routing_id(), player_id, duration, width, height, success));
   if (fullscreen_player_id_ != -1)
-    video_view_.UpdateMediaMetadata();
+    video_view_->UpdateMediaMetadata();
 }
 
 void MediaPlayerManagerImpl::OnPlaybackComplete(int player_id) {
   Send(new MediaPlayerMsg_MediaPlaybackCompleted(routing_id(), player_id));
   if (fullscreen_player_id_ != -1)
-    video_view_.OnPlaybackComplete();
+    video_view_->OnPlaybackComplete();
 }
 
 void MediaPlayerManagerImpl::OnMediaInterrupted(int player_id) {
   // Tell WebKit that the audio should be paused, then release all resources
   Send(new MediaPlayerMsg_DidMediaPlayerPause(routing_id(), player_id));
   OnReleaseResources(player_id);
 }
 
 void MediaPlayerManagerImpl::OnBufferingUpdate(
     int player_id, int percentage) {
   Send(new MediaPlayerMsg_MediaBufferingUpdate(
       routing_id(), player_id, percentage));
   if (fullscreen_player_id_ != -1)
-    video_view_.OnBufferingUpdate(percentage);
+    video_view_->OnBufferingUpdate(percentage);
 }
 
 void MediaPlayerManagerImpl::OnSeekComplete(int player_id,
                                             base::TimeDelta current_time) {
   Send(new MediaPlayerMsg_MediaSeekCompleted(
       routing_id(), player_id, current_time));
 }
 
 void MediaPlayerManagerImpl::OnMediaSeekRequest(
     int player_id, base::TimeDelta time_to_seek, bool request_surface) {
   bool request_texture_peer = request_surface;
-  if (request_surface && player_id == fullscreen_player_id_) {
-    video_view_.CreateContentVideoView();
+  if (request_surface && player_id == fullscreen_player_id_ &&
+      video_view_.get()) {
+    video_view_->OpenVideo();
     request_texture_peer = false;
   }
   Send(new MediaPlayerMsg_MediaSeekRequest(
       routing_id(), player_id, time_to_seek, request_texture_peer));
 }
 
 void MediaPlayerManagerImpl::OnError(int player_id, int error) {
   Send(new MediaPlayerMsg_MediaError(routing_id(), player_id, error));
   if (fullscreen_player_id_ != -1)
-    video_view_.OnMediaPlayerError(error);
+    video_view_->OnMediaPlayerError(error);
 }
 
 void MediaPlayerManagerImpl::OnVideoSizeChanged(
     int player_id, int width, int height) {
   Send(new MediaPlayerMsg_MediaVideoSizeChanged(routing_id(), player_id,
       width, height));
   if (fullscreen_player_id_ != -1)
-    video_view_.OnVideoSizeChanged(width, height);
+    video_view_->OnVideoSizeChanged(width, height);
 }
 
 void MediaPlayerManagerImpl::OnTimeUpdate(int player_id,
                                              base::TimeDelta current_time) {
   Send(new MediaPlayerMsg_MediaTimeUpdate(
       routing_id(), player_id, current_time));
 }
 
 void MediaPlayerManagerImpl::OnReadFromDemuxer(
     int player_id, media::DemuxerStream::Type type, bool seek_done) {
@@ skipping 47 matching lines @@
   for (ScopedVector<MediaPlayerAndroid>::iterator it = players_.begin();
       it != players_.end(); ++it) {
     if ((*it)->player_id() == player_id) {
       players_.erase(it);
       break;
     }
   }
 }
 
 }  // namespace content