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

media/base/android/media_codec_decoder_unittest.cc

 // Copyright 2015 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 <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 209 matching lines @@
   bool is_timeout_expired_;
 
   bool is_prefetched_;
   bool is_stopped_;
   bool is_starved_;
   base::TimeDelta stop_request_time_;
 
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   FrameStatistics frame_statistics_;
   DataAvailableCallback data_available_cb_;
-  scoped_refptr<gfx::SurfaceTexture> surface_texture_;
+  scoped_refptr<gl::SurfaceTexture> surface_texture_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaCodecDecoderTest);
 };
 
 MediaCodecDecoderTest::MediaCodecDecoderTest()
     : is_timeout_expired_(false),
       is_prefetched_(false),
       is_stopped_(false),
       is_starved_(false),
       stop_request_time_(kNoTimestamp()),
@@ skipping 71 matching lines @@
   DemuxerData data;
   base::TimeDelta delay;
   if (!data_factory_->CreateChunk(&data, &delay))
     return;
 
   task_runner_->PostDelayedTask(FROM_HERE, base::Bind(data_available_cb_, data),
                                 delay);
 }
 
 void MediaCodecDecoderTest::SetVideoSurface() {
-  surface_texture_ = gfx::SurfaceTexture::Create(0);
-  gfx::ScopedJavaSurface surface(surface_texture_.get());
+  surface_texture_ = gl::SurfaceTexture::Create(0);
+  gl::ScopedJavaSurface surface(surface_texture_.get());
   ASSERT_NE(nullptr, decoder_.get());
   VideoMediaCodecDecoder* video_decoder =
       static_cast<VideoMediaCodecDecoder*>(decoder_.get());
   video_decoder->SetVideoSurface(std::move(surface));
 }
 
 TEST_F(MediaCodecDecoderTest, AudioPrefetch) {
   CreateAudioDecoder();
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(500);
@@ skipping 100 matching lines @@
 
   decoder_->Prefetch(base::Bind(&MediaCodecDecoderTest::SetPrefetched,
                                 base::Unretained(this), true));
 
   EXPECT_TRUE(WaitForCondition(base::Bind(&MediaCodecDecoderTest::is_prefetched,
                                           base::Unretained(this))));
 
   decoder_->SetDemuxerConfigs(GetConfigs());
 
   // Prepare the surface.
-  scoped_refptr<gfx::SurfaceTexture> surface_texture(
-      gfx::SurfaceTexture::Create(0));
-  gfx::ScopedJavaSurface surface(surface_texture.get());
+  scoped_refptr<gl::SurfaceTexture> surface_texture(
+      gl::SurfaceTexture::Create(0));
+  gl::ScopedJavaSurface surface(surface_texture.get());
 
   // Release the surface texture.
   surface_texture = NULL;
 
   VideoMediaCodecDecoder* video_decoder =
       static_cast<VideoMediaCodecDecoder*>(decoder_.get());
   video_decoder->SetVideoSurface(std::move(surface));
 
   EXPECT_EQ(MediaCodecDecoder::kConfigFailure, decoder_->Configure(nullptr));
 }
@@ skipping 299 matching lines @@
 
   EXPECT_TRUE(decoder_->IsStopped());
   EXPECT_TRUE(decoder_->IsCompleted());
   EXPECT_EQ(data_factory_->last_pts(), pts_stat_.max());
 
   // Check that the reported video size is the one from the in-stream configs.
   EXPECT_EQ(data_factory_->GetConfigs().video_size, video_size_);
 }
 
 }  // namespace media