Migrate content/common/gpu/media code to media/gpu

media/gpu/android_deferred_rendering_backing_strategy.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 "content/common/gpu/media/android_deferred_rendering_backing_strategy.h"
+#include "media/gpu/android_deferred_rendering_backing_strategy.h"
 
 #include <EGL/egl.h>
 #include <EGL/eglext.h>
 
 #include "base/android/build_info.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
-#include "content/common/gpu/media/avda_codec_image.h"
-#include "content/common/gpu/media/avda_return_on_failure.h"
-#include "content/common/gpu/media/avda_shared_state.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/gl_stream_texture_image.h"
 #include "gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.h"
 #include "gpu/command_buffer/service/texture_manager.h"
 #include "gpu/ipc/common/gpu_surface_lookup.h"
 #include "gpu/ipc/service/gpu_channel.h"
+#include "media/gpu/avda_codec_image.h"
+#include "media/gpu/avda_return_on_failure.h"
+#include "media/gpu/avda_shared_state.h"
 #include "ui/gl/android/surface_texture.h"
 #include "ui/gl/egl_util.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_surface_egl.h"
 #include "ui/gl/scoped_binders.h"
 #include "ui/gl/scoped_make_current.h"
 
-namespace content {
+namespace media {
 
 AndroidDeferredRenderingBackingStrategy::
     AndroidDeferredRenderingBackingStrategy(AVDAStateProvider* state_provider)
     : state_provider_(state_provider), media_codec_(nullptr) {}
 
 AndroidDeferredRenderingBackingStrategy::
     ~AndroidDeferredRenderingBackingStrategy() {}
 
 gfx::ScopedJavaSurface AndroidDeferredRenderingBackingStrategy::Initialize(
     int surface_view_id) {
@@ skipping 254 matching lines @@
     gfx::ScopedTextureBinder texture_binder(GL_TEXTURE_2D, tmp_texture_id);
     // The target texture's size will exactly match the source.
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, size.width(), size.height(), 0,
                  GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
   }
 
-
-
   float transform_matrix[16];
   surface_texture_->GetTransformMatrix(transform_matrix);
 
   gpu::CopyTextureCHROMIUMResourceManager copier;
   copier.Initialize(
       gl_decoder,
       gl_decoder->GetContextGroup()->feature_info()->feature_flags());
   copier.DoCopyTextureWithTransform(gl_decoder, GL_TEXTURE_EXTERNAL_OES,
                                     shared_state_->surface_texture_service_id(),
                                     GL_TEXTURE_2D, tmp_texture_id, size.width(),
@@ skipping 23 matching lines @@
       continue;
     gfx::ScopedTextureBinder texture_binder(
         GL_TEXTURE_EXTERNAL_OES, texture_ref->texture()->service_id());
     glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, egl_image);
     DCHECK_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
   }
 
   EGLBoolean result =
       eglDestroyImageKHR(gfx::GLSurfaceEGL::GetHardwareDisplay(), egl_image);
   if (result == EGL_FALSE) {
-    DLOG(ERROR) << "Error destroying EGLImage: "
-                << ui::GetLastEGLErrorString();
+    DLOG(ERROR) << "Error destroying EGLImage: " << ui::GetLastEGLErrorString();
   }
 }
 
 bool AndroidDeferredRenderingBackingStrategy::DoesSurfaceTextureDetachWork()
     const {
   bool surface_texture_detach_works = true;
   if (gpu::gles2::GLES2Decoder* gl_decoder =
           state_provider_->GetGlDecoder().get()) {
     if (gpu::gles2::ContextGroup* group = gl_decoder->GetContextGroup()) {
       if (gpu::gles2::FeatureInfo* feature_info = group->feature_info()) {
@@ skipping 17 matching lines @@
     }
   }
 
   return surface_texture_detach_works;
 }
 
 bool AndroidDeferredRenderingBackingStrategy::ShouldCopyPictures() const {
   // Mali + <= KitKat crashes when we try to do this.  We don't know if it's
   // due to detaching a surface texture, but it's the same set of devices.
   if (!DoesSurfaceTextureDetachWork())
-      return false;
+    return false;
 
   // Other devices are unreliable for other reasons (e.g., EGLImage).
   if (gpu::gles2::GLES2Decoder* gl_decoder =
           state_provider_->GetGlDecoder().get()) {
     if (gpu::gles2::ContextGroup* group = gl_decoder->GetContextGroup()) {
       if (gpu::gles2::FeatureInfo* feature_info = group->feature_info()) {
-          return !feature_info->workarounds().avda_dont_copy_pictures;
+        return !feature_info->workarounds().avda_dont_copy_pictures;
       }
     }
   }
 
   // Assume so.
   return true;
 }
 
-}  // namespace content
+}  // namespace media