Refactoring ContentVideoViewContextDelegate.java

content/browser/android/media_player_manager_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 "content/browser/android/media_player_manager_android.h"
 
 #include "base/bind.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.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::MediaPlayerBridge;
 
 // Threshold on the number of media players per renderer before we start
 // attempting to release inactive media players.
 static const int kMediaPlayerThreshold = 1;
 
 namespace content {
 
 MediaPlayerManagerAndroid::MediaPlayerManagerAndroid(
     RenderViewHost* render_view_host)
     : RenderViewHostObserver(render_view_host),
-      ALLOW_THIS_IN_INITIALIZER_LIST(video_view_(this)),
       fullscreen_player_id_(-1),
       web_contents_(WebContents::FromRenderViewHost(render_view_host)) {
 }
 
 MediaPlayerManagerAndroid::~MediaPlayerManagerAndroid() {}
 
 bool MediaPlayerManagerAndroid::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(MediaPlayerManagerAndroid, msg)
     IPC_MESSAGE_HANDLER(MediaPlayerHostMsg_EnterFullscreen, OnEnterFullscreen)
@@ skipping 42 matching lines @@
   Send(new MediaPlayerMsg_DidExitFullscreen(
       routing_id(), fullscreen_player_id_));
   MediaPlayerBridge* player = GetFullscreenPlayer();
   fullscreen_player_id_ = -1;
   if (!player)
     return;
   if (release_media_player)
     player->Release();
   else
     player->SetVideoSurface(NULL);
+  video_view_.reset();
 }
 
 void MediaPlayerManagerAndroid::SetVideoSurface(jobject surface) {
   MediaPlayerBridge* player = GetFullscreenPlayer();
   if (player) {
     player->SetVideoSurface(surface);
     Send(new MediaPlayerMsg_DidEnterFullscreen(
         routing_id(), player->player_id()));
   }
 }
@@ skipping 48 matching lines @@
 }
 
 void MediaPlayerManagerAndroid::OnPause(int player_id) {
   MediaPlayerBridge* player = GetPlayer(player_id);
   if (player)
     player->Pause();
 }
 
 void MediaPlayerManagerAndroid::OnEnterFullscreen(int player_id) {
   DCHECK_EQ(fullscreen_player_id_, -1);
-
-  fullscreen_player_id_ = player_id;
-  video_view_.CreateContentVideoView();
+  if (video_view_.get())
+    video_view_->OpenVideo();
+  else {
+    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(),

[joth, 2013/05/15 22:38:57]

I'm not sure what stops two competing ContentViewCores from both getting here
when trying to enter fullscreen, and the second will then hit the singleton
DCHECK inside the ContentVideoView constructor?

Would it be better to have a ContentVideoView::Create() method, and inside there
we can detect there's already a fullscreen view and tear it down? (THis would
avoid the need for the code you have in AwContentClient to exit fullscreen)

[michaelbai, 2013/05/22 18:08:39]

hmm, that's no a common use case, it needs user's action to toggle to fullscreen
video, I just made the second one fail.


On 2013/05/15 22:38:57, joth wrote:

+        content_view_core_impl->GetContentVideoViewClient(), this));
+  }
 }
 
 void MediaPlayerManagerAndroid::OnExitFullscreen(int player_id) {
   if (fullscreen_player_id_ == player_id) {
     MediaPlayerBridge* player = GetPlayer(player_id);
     if (player)
       player->SetVideoSurface(NULL);
-    video_view_.DestroyContentVideoView();
     fullscreen_player_id_ = -1;
+    video_view_->OnExitFullscreen();
+    video_view_.reset();
   }
 }
 
 void MediaPlayerManagerAndroid::OnReleaseResources(int player_id) {
   MediaPlayerBridge* 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 MediaPlayerManagerAndroid::OnDestroyPlayer(int player_id) {
   for (ScopedVector<MediaPlayerBridge>::iterator it = players_.begin();
       it != players_.end(); ++it) {
     if ((*it)->player_id() == player_id) {
       players_.erase(it);
       break;
     }
   }
   if (fullscreen_player_id_ == player_id)
     fullscreen_player_id_ = -1;
 }
 
 void MediaPlayerManagerAndroid::DestroyAllMediaPlayers() {
   players_.clear();
   if (fullscreen_player_id_ != -1) {
-    video_view_.DestroyContentVideoView();
+    video_view_.reset();
     fullscreen_player_id_ = -1;
   }
 }
 
 void MediaPlayerManagerAndroid::AttachExternalVideoSurface(int player_id,
                                                            jobject surface) {
   MediaPlayerBridge* player = GetPlayer(player_id);
   if (player)
     player->SetVideoSurface(surface);
 }
@@ skipping 25 matching lines @@
 MediaPlayerBridge* MediaPlayerManagerAndroid::GetFullscreenPlayer() {
   return GetPlayer(fullscreen_player_id_);
 }
 
 void MediaPlayerManagerAndroid::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 MediaPlayerManagerAndroid::OnPlaybackComplete(int player_id) {
   Send(new MediaPlayerMsg_MediaPlaybackCompleted(routing_id(), player_id));
   if (fullscreen_player_id_ != -1)
-    video_view_.OnPlaybackComplete();
+    video_view_->OnPlaybackComplete();
 }
 
 void MediaPlayerManagerAndroid::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 MediaPlayerManagerAndroid::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 MediaPlayerManagerAndroid::OnSeekComplete(int player_id,
                                                base::TimeDelta current_time) {
   Send(new MediaPlayerMsg_MediaSeekCompleted(
       routing_id(), player_id, current_time));
 }
 
 void MediaPlayerManagerAndroid::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 MediaPlayerManagerAndroid::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 MediaPlayerManagerAndroid::OnTimeUpdate(int player_id,
                                              base::TimeDelta current_time) {
   Send(new MediaPlayerMsg_MediaTimeUpdate(
       routing_id(), player_id, current_time));
 }
 
 void MediaPlayerManagerAndroid::RequestMediaResources(
     MediaPlayerBridge* player) {
@@ skipping 26 matching lines @@
     }
   }
 }
 
 void MediaPlayerManagerAndroid::ReleaseMediaResources(
     MediaPlayerBridge* player) {
   // Nothing needs to be done.
 }
 
 }  // namespace content