Move code in ui/gl/* from gfx:: to gl::

content/browser/media/android/browser_media_player_manager.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/browser/media/android/browser_media_player_manager.h"
 
 #include <utility>
 
 #include "base/android/scoped_java_ref.h"
 #include "base/memory/singleton.h"
@@ skipping 44 matching lines @@
   static BrowserSurfaceTexturePeer* GetInstance();
 
  private:
   friend struct base::DefaultSingletonTraits<BrowserSurfaceTexturePeer>;
 
   BrowserSurfaceTexturePeer();
   ~BrowserSurfaceTexturePeer() override;
 
   void EstablishSurfaceTexturePeer(
       base::ProcessHandle render_process_handle,
-      scoped_refptr<gfx::SurfaceTexture> surface_texture,
+      scoped_refptr<gl::SurfaceTexture> surface_texture,
       int render_frame_id,
       int player_id) override;
 
   DISALLOW_COPY_AND_ASSIGN(BrowserSurfaceTexturePeer);
 };
 
 // static
 BrowserSurfaceTexturePeer* BrowserSurfaceTexturePeer::GetInstance() {
   return base::Singleton<
       BrowserSurfaceTexturePeer,
       base::LeakySingletonTraits<BrowserSurfaceTexturePeer>>::get();
 }
 
 BrowserSurfaceTexturePeer::BrowserSurfaceTexturePeer() {
   gpu::SurfaceTexturePeer::InitInstance(this);
 }
 
 BrowserSurfaceTexturePeer::~BrowserSurfaceTexturePeer() {
   gpu::SurfaceTexturePeer::InitInstance(nullptr);
 }
 
 void BrowserSurfaceTexturePeer::EstablishSurfaceTexturePeer(
     base::ProcessHandle render_process_handle,
-    scoped_refptr<gfx::SurfaceTexture> surface_texture,
+    scoped_refptr<gl::SurfaceTexture> surface_texture,
     int render_frame_id,
     int player_id) {
   if (!surface_texture.get())
     return;
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&BrowserMediaPlayerManager::SetSurfacePeer, surface_texture,
                  render_process_handle, render_frame_id, player_id));
 }
 
@@ skipping 23 matching lines @@
   media_url_interceptor_ = media_url_interceptor;
 }
 
 // static
 void BrowserMediaPlayerManager::InitSurfaceTexturePeer() {
   BrowserSurfaceTexturePeer::GetInstance();
 }
 
 // static
 void BrowserMediaPlayerManager::SetSurfacePeer(
-    scoped_refptr<gfx::SurfaceTexture> surface_texture,
+    scoped_refptr<gl::SurfaceTexture> surface_texture,
     base::ProcessHandle render_process_handle,
     int render_frame_id,
     int player_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   int render_process_id = 0;
   RenderProcessHost::iterator it = RenderProcessHost::AllHostsIterator();
   while (!it.IsAtEnd()) {
     if (it.GetCurrentValue()->GetHandle() == render_process_handle) {
       render_process_id = it.GetCurrentValue()->GetID();
       break;
@@ skipping 22 matching lines @@
     return;
   }
 
   media::MediaPlayerAndroid* player = player_manager->GetPlayer(player_id);
   if (!player) {
     DVLOG(1) << "Cannot find media player for player_id " << player_id;
     return;
   }
 
   if (player != player_manager->GetFullscreenPlayer()) {
-    gfx::ScopedJavaSurface scoped_surface(surface_texture.get());
+    gl::ScopedJavaSurface scoped_surface(surface_texture.get());
     player->SetVideoSurface(std::move(scoped_surface));
   }
 }
 
 // static
 BrowserMediaPlayerManager* BrowserMediaPlayerManager::Create(
     RenderFrameHost* rfh) {
   if (g_factory)
     return g_factory(rfh);
   return new BrowserMediaPlayerManager(rfh);
@@ skipping 122 matching lines @@
     return;
 
 #if defined(VIDEO_HOLE)
   if (external_video_surface_container_)
     external_video_surface_container_->OnFrameInfoUpdated();
 #endif  // defined(VIDEO_HOLE)
 
   if (release_media_player)
     ReleaseFullscreenPlayer(player);
   else
-    player->SetVideoSurface(gfx::ScopedJavaSurface());
+    player->SetVideoSurface(gl::ScopedJavaSurface());
 #endif  // defined(USE_AURA)
 }
 
 void BrowserMediaPlayerManager::OnTimeUpdate(
     int player_id,
     base::TimeDelta current_timestamp,
     base::TimeTicks current_time_ticks) {
   Send(new MediaPlayerMsg_MediaTimeUpdate(
       RoutingID(), player_id, current_timestamp, current_time_ticks));
 }
 
-void BrowserMediaPlayerManager::SetVideoSurface(
-    gfx::ScopedJavaSurface surface) {
+void BrowserMediaPlayerManager::SetVideoSurface(gl::ScopedJavaSurface surface) {
   MediaPlayerAndroid* player = GetFullscreenPlayer();
   if (!player)
     return;
 
   bool empty_surface = surface.IsEmpty();
   player->SetVideoSurface(std::move(surface));
   if (empty_surface)
     return;
 
   // If we already know the size, set it now. Otherwise it will be set when the
@@ skipping 116 matching lines @@
                     player_id_to_delegate_id_map_[player_id], has_audio,
                     IsPlayingRemotely(player_id), duration);
 }
 
 #if defined(VIDEO_HOLE)
 void BrowserMediaPlayerManager::AttachExternalVideoSurface(int player_id,
                                                            jobject surface) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (player) {
     player->SetVideoSurface(
-        gfx::ScopedJavaSurface::AcquireExternalSurface(surface));
+        gl::ScopedJavaSurface::AcquireExternalSurface(surface));
   }
 }
 
 void BrowserMediaPlayerManager::DetachExternalVideoSurface(int player_id) {
   MediaPlayerAndroid* player = GetPlayer(player_id);
   if (player)
-    player->SetVideoSurface(gfx::ScopedJavaSurface());
+    player->SetVideoSurface(gl::ScopedJavaSurface());
 }
 
 void BrowserMediaPlayerManager::OnFrameInfoUpdated() {
   if (fullscreen_player_id_ != kInvalidMediaPlayerId)
     return;
 
   if (external_video_surface_container_)
     external_video_surface_container_->OnFrameInfoUpdated();
 }
 
@@ skipping 311 matching lines @@
   if (!player)
     return;
   player->Start();
   if (fullscreen_player_id_ == player_id && fullscreen_player_is_released_) {
     video_view_->OpenVideo();
     fullscreen_player_is_released_ = false;
   }
 }
 
 }  // namespace content