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

media/gpu/vaapi_wrapper.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/common/gpu/media/vaapi_wrapper.h"
+#include "media/gpu/vaapi_wrapper.h"
 
 #include <dlfcn.h>
 #include <string.h>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/sys_info.h"
 #include "build/build_config.h"
+
 // Auto-generated for dlopen libva libraries
-#include "content/common/gpu/media/va_stubs.h"
-#include "content/common/gpu/media/vaapi_picture.h"
+#include "media/gpu/va_stubs.h"
+
+#include "media/gpu/vaapi_picture.h"
 #include "third_party/libyuv/include/libyuv.h"
 #include "ui/gl/gl_bindings.h"
+
 #if defined(USE_X11)
 #include "ui/gfx/x/x11_types.h"
 #elif defined(USE_OZONE)
 #include "third_party/libva/va/drm/va_drm.h"
 #include "third_party/libva/va/va_drmcommon.h"
 #include "ui/ozone/public/ozone_platform.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 #endif  // USE_X11
 
-using content_common_gpu_media::kModuleVa;
+using media_gpu::kModuleVa;
 #if defined(USE_X11)
-using content_common_gpu_media::kModuleVa_x11;
+using media_gpu::kModuleVa_x11;
 #elif defined(USE_OZONE)
-using content_common_gpu_media::kModuleVa_drm;
+using media_gpu::kModuleVa_drm;
 #endif  // USE_X11
-using content_common_gpu_media::InitializeStubs;
-using content_common_gpu_media::StubPathMap;
+using media_gpu::InitializeStubs;
+using media_gpu::StubPathMap;
 
-#define LOG_VA_ERROR_AND_REPORT(va_error, err_msg)         \
-  do {                                                     \
-    LOG(ERROR) << err_msg                                  \
-             << " VA error: " << vaErrorStr(va_error);     \
-    report_error_to_uma_cb_.Run();                         \
+#define LOG_VA_ERROR_AND_REPORT(va_error, err_msg)                  \
+  do {                                                              \
+    LOG(ERROR) << err_msg << " VA error: " << vaErrorStr(va_error); \
+    report_error_to_uma_cb_.Run();                                  \
   } while (0)
 
-#define VA_LOG_ON_ERROR(va_error, err_msg)                 \
-  do {                                                     \
-    if ((va_error) != VA_STATUS_SUCCESS)                   \
-      LOG_VA_ERROR_AND_REPORT(va_error, err_msg);          \
+#define VA_LOG_ON_ERROR(va_error, err_msg)        \
+  do {                                            \
+    if ((va_error) != VA_STATUS_SUCCESS)          \
+      LOG_VA_ERROR_AND_REPORT(va_error, err_msg); \
   } while (0)
 
-#define VA_SUCCESS_OR_RETURN(va_error, err_msg, ret)       \
-  do {                                                     \
-    if ((va_error) != VA_STATUS_SUCCESS) {                 \
-      LOG_VA_ERROR_AND_REPORT(va_error, err_msg);          \
-      return (ret);                                        \
-    }                                                      \
+#define VA_SUCCESS_OR_RETURN(va_error, err_msg, ret) \
+  do {                                               \
+    if ((va_error) != VA_STATUS_SUCCESS) {           \
+      LOG_VA_ERROR_AND_REPORT(va_error, err_msg);    \
+      return (ret);                                  \
+    }                                                \
   } while (0)
 
 #if defined(USE_OZONE)
 namespace {
 
 uint32_t BufferFormatToVAFourCC(gfx::BufferFormat fmt) {
   switch (fmt) {
     case gfx::BufferFormat::BGRX_8888:
       return VA_FOURCC_BGRX;
     case gfx::BufferFormat::UYVY_422:
@@ skipping 12 matching lines @@
       return VA_RT_FORMAT_RGB32;
     default:
       NOTREACHED();
       return 0;
   }
 }
 
 }  // namespace
 #endif
 
-namespace content {
+namespace media {
 
 // Maximum framerate of encoded profile. This value is an arbitary limit
 // and not taken from HW documentation.
 const int kMaxEncoderFramerate = 30;
 
 base::LazyInstance<VaapiWrapper::VADisplayState>
     VaapiWrapper::va_display_state_ = LAZY_INSTANCE_INITIALIZER;
 
 base::LazyInstance<VaapiWrapper::LazyProfileInfos>
     VaapiWrapper::profile_infos_ = LAZY_INSTANCE_INITIALIZER;
@@ skipping 25 matching lines @@
     {media::VP8PROFILE_ANY, VAProfileVP8Version0_3},
     // TODO(servolk): Need to add VP9 profiles 1,2,3 here after rolling
     // third_party/libva to 1.7. crbug.com/598118
     {media::VP9PROFILE_PROFILE0, VAProfileVP9Profile0},
 };
 
 static std::vector<VAConfigAttrib> GetRequiredAttribs(
     VaapiWrapper::CodecMode mode) {
   std::vector<VAConfigAttrib> required_attribs;
   required_attribs.insert(
-      required_attribs.end(),
-      kCommonVAConfigAttribs,
+      required_attribs.end(), kCommonVAConfigAttribs,
       kCommonVAConfigAttribs + arraysize(kCommonVAConfigAttribs));
   if (mode == VaapiWrapper::kEncode) {
     required_attribs.insert(
-        required_attribs.end(),
-        kEncodeVAConfigAttribs,
+        required_attribs.end(), kEncodeVAConfigAttribs,
         kEncodeVAConfigAttribs + arraysize(kEncodeVAConfigAttribs));
   }
   return required_attribs;
 }
 
 VASurface::VASurface(VASurfaceID va_surface_id,
                      const gfx::Size& size,
                      unsigned int format,
                      const ReleaseCB& release_cb)
     : va_surface_id_(va_surface_id),
@@ skipping 109 matching lines @@
 
 // static
 bool VaapiWrapper::IsJpegDecodeSupported() {
   return profile_infos_.Get().IsProfileSupported(kDecode,
                                                  VAProfileJPEGBaseline);
 }
 
 void VaapiWrapper::TryToSetVADisplayAttributeToLocalGPU() {
   base::AutoLock auto_lock(*va_lock_);
   VADisplayAttribute item = {VADisplayAttribRenderMode,
-                             1,  // At least support '_LOCAL_OVERLAY'.
+                             1,   // At least support '_LOCAL_OVERLAY'.
                              -1,  // The maximum possible support 'ALL'.
                              VA_RENDER_MODE_LOCAL_GPU,
                              VA_DISPLAY_ATTRIB_SETTABLE};
 
   VAStatus va_res = vaSetDisplayAttributes(va_display_, &item, 1);
   if (va_res != VA_STATUS_SUCCESS)
     DVLOG(2) << "vaSetDisplayAttributes unsupported, ignoring by default.";
 }
 
 // static
-VAProfile VaapiWrapper::ProfileToVAProfile(
-    media::VideoCodecProfile profile, CodecMode mode) {
+VAProfile VaapiWrapper::ProfileToVAProfile(media::VideoCodecProfile profile,
+                                           CodecMode mode) {
   VAProfile va_profile = VAProfileNone;
   for (size_t i = 0; i < arraysize(kProfileMap); ++i) {
     if (kProfileMap[i].profile == profile) {
       va_profile = kProfileMap[i].va_profile;
       break;
     }
   }
   if (!profile_infos_.Get().IsProfileSupported(mode, va_profile) &&
       va_profile == VAProfileH264Baseline) {
     // crbug.com/345569: media::ProfileIDToVideoCodecProfile() currently strips
     // the information whether the profile is constrained or not, so we have no
     // way to know here. Try for baseline first, but if it is not supported,
     // try constrained baseline and hope this is what it actually is
     // (which in practice is true for a great majority of cases).
     if (profile_infos_.Get().IsProfileSupported(
-          mode, VAProfileH264ConstrainedBaseline)) {
+            mode, VAProfileH264ConstrainedBaseline)) {
       va_profile = VAProfileH264ConstrainedBaseline;
       DVLOG(1) << "Fall back to constrained baseline profile.";
     }
   }
   return va_profile;
 }
 
 std::vector<VaapiWrapper::ProfileInfo>
 VaapiWrapper::GetSupportedProfileInfosForCodecModeInternal(CodecMode mode) {
   std::vector<ProfileInfo> supported_profile_infos;
   std::vector<VAProfile> va_profiles;
   if (!GetSupportedVaProfiles(&va_profiles))
     return supported_profile_infos;
 
   std::vector<VAConfigAttrib> required_attribs = GetRequiredAttribs(mode);
   VAEntrypoint entrypoint =
-      (mode == kEncode ? VAEntrypointEncSlice: VAEntrypointVLD);
+      (mode == kEncode ? VAEntrypointEncSlice : VAEntrypointVLD);
 
   base::AutoLock auto_lock(*va_lock_);
   for (const auto& va_profile : va_profiles) {
     if (!IsEntrypointSupported_Locked(va_profile, entrypoint))
       continue;
     if (!AreAttribsSupported_Locked(va_profile, entrypoint, required_attribs))
       continue;
     ProfileInfo profile_info;
-    if (!GetMaxResolution_Locked(va_profile,
-                                 entrypoint,
-                                 required_attribs,
+    if (!GetMaxResolution_Locked(va_profile, entrypoint, required_attribs,
                                  &profile_info.max_resolution)) {
       LOG(ERROR) << "GetMaxResolution failed for va_profile " << va_profile
                  << " and entrypoint " << entrypoint;
       continue;
     }
     profile_info.va_profile = va_profile;
     supported_profile_infos.push_back(profile_info);
   }
   return supported_profile_infos;
 }
@@ skipping 33 matching lines @@
 }
 
 bool VaapiWrapper::GetSupportedVaProfiles(std::vector<VAProfile>* profiles) {
   base::AutoLock auto_lock(*va_lock_);
   // Query the driver for supported profiles.
   int max_profiles = vaMaxNumProfiles(va_display_);
   std::vector<VAProfile> supported_profiles(
       base::checked_cast<size_t>(max_profiles));
 
   int num_supported_profiles;
-  VAStatus va_res = vaQueryConfigProfiles(
-      va_display_, &supported_profiles[0], &num_supported_profiles);
+  VAStatus va_res = vaQueryConfigProfiles(va_display_, &supported_profiles[0],
+                                          &num_supported_profiles);
   VA_SUCCESS_OR_RETURN(va_res, "vaQueryConfigProfiles failed", false);
   if (num_supported_profiles < 0 || num_supported_profiles > max_profiles) {
     LOG(ERROR) << "vaQueryConfigProfiles returned: " << num_supported_profiles;
     return false;
   }
 
   supported_profiles.resize(base::checked_cast<size_t>(num_supported_profiles));
   *profiles = supported_profiles;
   return true;
 }
 
 bool VaapiWrapper::IsEntrypointSupported_Locked(VAProfile va_profile,
                                                 VAEntrypoint entrypoint) {
   va_lock_->AssertAcquired();
   // Query the driver for supported entrypoints.
   int max_entrypoints = vaMaxNumEntrypoints(va_display_);
   std::vector<VAEntrypoint> supported_entrypoints(
       base::checked_cast<size_t>(max_entrypoints));
 
   int num_supported_entrypoints;
-  VAStatus va_res = vaQueryConfigEntrypoints(va_display_,
-                                             va_profile,
+  VAStatus va_res = vaQueryConfigEntrypoints(va_display_, va_profile,
                                              &supported_entrypoints[0],
                                              &num_supported_entrypoints);
   VA_SUCCESS_OR_RETURN(va_res, "vaQueryConfigEntrypoints failed", false);
   if (num_supported_entrypoints < 0 ||
       num_supported_entrypoints > max_entrypoints) {
     LOG(ERROR) << "vaQueryConfigEntrypoints returned: "
                << num_supported_entrypoints;
     return false;
   }
 
-  if (std::find(supported_entrypoints.begin(),
-                supported_entrypoints.end(),
+  if (std::find(supported_entrypoints.begin(), supported_entrypoints.end(),
                 entrypoint) == supported_entrypoints.end()) {
     DVLOG(1) << "Unsupported entrypoint";
     return false;
   }
   return true;
 }
 
 bool VaapiWrapper::AreAttribsSupported_Locked(
     VAProfile va_profile,
     VAEntrypoint entrypoint,
     const std::vector<VAConfigAttrib>& required_attribs) {
   va_lock_->AssertAcquired();
   // Query the driver for required attributes.
   std::vector<VAConfigAttrib> attribs = required_attribs;
   for (size_t i = 0; i < required_attribs.size(); ++i)
     attribs[i].value = 0;
 
-  VAStatus va_res = vaGetConfigAttributes(
-      va_display_, va_profile, entrypoint, &attribs[0], attribs.size());
+  VAStatus va_res = vaGetConfigAttributes(va_display_, va_profile, entrypoint,
+                                          &attribs[0], attribs.size());
   VA_SUCCESS_OR_RETURN(va_res, "vaGetConfigAttributes failed", false);
 
   for (size_t i = 0; i < required_attribs.size(); ++i) {
     if (attribs[i].type != required_attribs[i].type ||
         (attribs[i].value & required_attribs[i].value) !=
             required_attribs[i].value) {
       DVLOG(1) << "Unsupported value " << required_attribs[i].value
                << " for attribute type " << required_attribs[i].type;
       return false;
     }
   }
   return true;
 }
 
 bool VaapiWrapper::GetMaxResolution_Locked(
     VAProfile va_profile,
     VAEntrypoint entrypoint,
     std::vector<VAConfigAttrib>& required_attribs,
     gfx::Size* resolution) {
   va_lock_->AssertAcquired();
   VAConfigID va_config_id;
-  VAStatus va_res = vaCreateConfig(
-      va_display_,
-      va_profile,
-      entrypoint,
-      &required_attribs[0],
-      required_attribs.size(),
-      &va_config_id);
+  VAStatus va_res =
+      vaCreateConfig(va_display_, va_profile, entrypoint, &required_attribs[0],
+                     required_attribs.size(), &va_config_id);
   VA_SUCCESS_OR_RETURN(va_res, "vaCreateConfig failed", false);
 
   // Calls vaQuerySurfaceAttributes twice. The first time is to get the number
   // of attributes to prepare the space and the second time is to get all
   // attributes.
   unsigned int num_attribs;
-  va_res = vaQuerySurfaceAttributes(
-      va_display_, va_config_id, nullptr, &num_attribs);
+  va_res = vaQuerySurfaceAttributes(va_display_, va_config_id, nullptr,
+                                    &num_attribs);
   VA_SUCCESS_OR_RETURN(va_res, "vaQuerySurfaceAttributes failed", false);
   if (!num_attribs)
     return false;
 
   std::vector<VASurfaceAttrib> attrib_list(
       base::checked_cast<size_t>(num_attribs));
 
-  va_res = vaQuerySurfaceAttributes(
-      va_display_, va_config_id, &attrib_list[0], &num_attribs);
+  va_res = vaQuerySurfaceAttributes(va_display_, va_config_id, &attrib_list[0],
+                                    &num_attribs);
   VA_SUCCESS_OR_RETURN(va_res, "vaQuerySurfaceAttributes failed", false);
 
   resolution->SetSize(0, 0);
   for (const auto& attrib : attrib_list) {
     if (attrib.type == VASurfaceAttribMaxWidth)
       resolution->set_width(attrib.value.value.i);
     else if (attrib.type == VASurfaceAttribMaxHeight)
       resolution->set_height(attrib.value.value.i);
   }
   if (resolution->IsEmpty()) {
     LOG(ERROR) << "Codec resolution " << resolution->ToString()
                << " cannot be zero.";
     return false;
   }
   return true;
 }
 
 bool VaapiWrapper::Initialize(CodecMode mode, VAProfile va_profile) {
   TryToSetVADisplayAttributeToLocalGPU();
 
   VAEntrypoint entrypoint =
-    (mode == kEncode ? VAEntrypointEncSlice : VAEntrypointVLD);
+      (mode == kEncode ? VAEntrypointEncSlice : VAEntrypointVLD);
   std::vector<VAConfigAttrib> required_attribs = GetRequiredAttribs(mode);
   base::AutoLock auto_lock(*va_lock_);
-  VAStatus va_res = vaCreateConfig(va_display_,
-                                   va_profile,
-                                   entrypoint,
-                                   &required_attribs[0],
-                                   required_attribs.size(),
-                                   &va_config_id_);
+  VAStatus va_res =
+      vaCreateConfig(va_display_, va_profile, entrypoint, &required_attribs[0],
+                     required_attribs.size(), &va_config_id_);
   VA_SUCCESS_OR_RETURN(va_res, "vaCreateConfig failed", false);
 
   return true;
 }
 
 void VaapiWrapper::Deinitialize() {
   base::AutoLock auto_lock(*va_lock_);
 
   if (va_config_id_ != VA_INVALID_ID) {
     VAStatus va_res = vaDestroyConfig(va_display_, va_config_id_);
@@ skipping 28 matching lines @@
       vaCreateSurfaces(va_display_, va_format, size.width(), size.height(),
                        &va_surface_ids_[0], va_surface_ids_.size(), NULL, 0);
 
   VA_LOG_ON_ERROR(va_res, "vaCreateSurfaces failed");
   if (va_res != VA_STATUS_SUCCESS) {
     va_surface_ids_.clear();
     return false;
   }
 
   // And create a context associated with them.
-  va_res = vaCreateContext(va_display_, va_config_id_,
-                           size.width(), size.height(), VA_PROGRESSIVE,
-                           &va_surface_ids_[0], va_surface_ids_.size(),
-                           &va_context_id_);
+  va_res = vaCreateContext(va_display_, va_config_id_, size.width(),
+                           size.height(), VA_PROGRESSIVE, &va_surface_ids_[0],
+                           va_surface_ids_.size(), &va_context_id_);
 
   VA_LOG_ON_ERROR(va_res, "vaCreateContext failed");
   if (va_res != VA_STATUS_SUCCESS) {
     DestroySurfaces();
     return false;
   }
 
   *va_surfaces = va_surface_ids_;
   va_surface_format_ = va_format;
   return true;
 }
 
 void VaapiWrapper::DestroySurfaces() {
   base::AutoLock auto_lock(*va_lock_);
-  DVLOG(2) << "Destroying " << va_surface_ids_.size()  << " surfaces";
+  DVLOG(2) << "Destroying " << va_surface_ids_.size() << " surfaces";
 
   if (va_context_id_ != VA_INVALID_ID) {
     VAStatus va_res = vaDestroyContext(va_display_, va_context_id_);
     VA_LOG_ON_ERROR(va_res, "vaDestroyContext failed");
   }
 
   if (!va_surface_ids_.empty()) {
     VAStatus va_res = vaDestroySurfaces(va_display_, &va_surface_ids_[0],
                                         va_surface_ids_.size());
     VA_LOG_ON_ERROR(va_res, "vaDestroySurfaces failed");
@@ skipping 114 matching lines @@
   VAStatus va_res = vaDestroySurfaces(va_display_, &va_surface_id, 1);
   VA_LOG_ON_ERROR(va_res, "vaDestroySurfaces on surface failed");
 }
 
 bool VaapiWrapper::SubmitBuffer(VABufferType va_buffer_type,
                                 size_t size,
                                 void* buffer) {
   base::AutoLock auto_lock(*va_lock_);
 
   VABufferID buffer_id;
-  VAStatus va_res = vaCreateBuffer(va_display_, va_context_id_,
-                                   va_buffer_type, size,
-                                   1, buffer, &buffer_id);
+  VAStatus va_res = vaCreateBuffer(va_display_, va_context_id_, va_buffer_type,
+                                   size, 1, buffer, &buffer_id);
   VA_SUCCESS_OR_RETURN(va_res, "Failed to create a VA buffer", false);
 
   switch (va_buffer_type) {
     case VASliceParameterBufferType:
     case VASliceDataBufferType:
     case VAEncSliceParameterBufferType:
       pending_slice_bufs_.push_back(buffer_id);
       break;
 
     default:
       pending_va_bufs_.push_back(buffer_id);
       break;
   }
 
   return true;
 }
 
 bool VaapiWrapper::SubmitVAEncMiscParamBuffer(
     VAEncMiscParameterType misc_param_type,
     size_t size,
     void* buffer) {
   base::AutoLock auto_lock(*va_lock_);
 
   VABufferID buffer_id;
-  VAStatus va_res = vaCreateBuffer(va_display_,
-                                   va_context_id_,
-                                   VAEncMiscParameterBufferType,
-                                   sizeof(VAEncMiscParameterBuffer) + size,
-                                   1,
-                                   NULL,
-                                   &buffer_id);
+  VAStatus va_res = vaCreateBuffer(
+      va_display_, va_context_id_, VAEncMiscParameterBufferType,
+      sizeof(VAEncMiscParameterBuffer) + size, 1, NULL, &buffer_id);
   VA_SUCCESS_OR_RETURN(va_res, "Failed to create a VA buffer", false);
 
   void* data_ptr = NULL;
   va_res = vaMapBuffer(va_display_, buffer_id, &data_ptr);
   VA_LOG_ON_ERROR(va_res, "vaMapBuffer failed");
   if (va_res != VA_STATUS_SUCCESS) {
     vaDestroyBuffer(va_display_, buffer_id);
     return false;
   }
 
@@ skipping 22 matching lines @@
     VAStatus va_res = vaDestroyBuffer(va_display_, pending_slice_buf);
     VA_LOG_ON_ERROR(va_res, "vaDestroyBuffer failed");
   }
 
   pending_va_bufs_.clear();
   pending_slice_bufs_.clear();
 }
 
 bool VaapiWrapper::CreateCodedBuffer(size_t size, VABufferID* buffer_id) {
   base::AutoLock auto_lock(*va_lock_);
-  VAStatus va_res = vaCreateBuffer(va_display_,
-                                   va_context_id_,
-                                   VAEncCodedBufferType,
-                                   size,
-                                   1,
-                                   NULL,
-                                   buffer_id);
+  VAStatus va_res =
+      vaCreateBuffer(va_display_, va_context_id_, VAEncCodedBufferType, size, 1,
+                     NULL, buffer_id);
   VA_SUCCESS_OR_RETURN(va_res, "Failed to create a coded buffer", false);
 
   const auto is_new_entry = coded_buffers_.insert(*buffer_id).second;
   DCHECK(is_new_entry);
   return true;
 }
 
 void VaapiWrapper::DestroyCodedBuffers() {
   base::AutoLock auto_lock(*va_lock_);
 
   for (std::set<VABufferID>::const_iterator iter = coded_buffers_.begin();
-       iter != coded_buffers_.end();
-       ++iter) {
+       iter != coded_buffers_.end(); ++iter) {
     VAStatus va_res = vaDestroyBuffer(va_display_, *iter);
     VA_LOG_ON_ERROR(va_res, "vaDestroyBuffer failed");
   }
 
   coded_buffers_.clear();
 }
 
 bool VaapiWrapper::Execute(VASurfaceID va_surface_id) {
   base::AutoLock auto_lock(*va_lock_);
 
   DVLOG(4) << "Pending VA bufs to commit: " << pending_va_bufs_.size();
   DVLOG(4) << "Pending slice bufs to commit: " << pending_slice_bufs_.size();
   DVLOG(4) << "Target VA surface " << va_surface_id;
 
   // Get ready to execute for given surface.
-  VAStatus va_res = vaBeginPicture(va_display_, va_context_id_,
-                                   va_surface_id);
+  VAStatus va_res = vaBeginPicture(va_display_, va_context_id_, va_surface_id);
   VA_SUCCESS_OR_RETURN(va_res, "vaBeginPicture failed", false);
 
   if (pending_va_bufs_.size() > 0) {
     // Commit parameter and slice buffers.
-    va_res = vaRenderPicture(va_display_,
-                             va_context_id_,
-                             &pending_va_bufs_[0],
+    va_res = vaRenderPicture(va_display_, va_context_id_, &pending_va_bufs_[0],
                              pending_va_bufs_.size());
     VA_SUCCESS_OR_RETURN(va_res, "vaRenderPicture for va_bufs failed", false);
   }
 
   if (pending_slice_bufs_.size() > 0) {
-    va_res = vaRenderPicture(va_display_,
-                             va_context_id_,
-                             &pending_slice_bufs_[0],
-                             pending_slice_bufs_.size());
+    va_res =
+        vaRenderPicture(va_display_, va_context_id_, &pending_slice_bufs_[0],
+                        pending_slice_bufs_.size());
     VA_SUCCESS_OR_RETURN(va_res, "vaRenderPicture for slices failed", false);
   }
 
   // Instruct HW codec to start processing committed buffers.
   // Does not block and the job is not finished after this returns.
   va_res = vaEndPicture(va_display_, va_context_id_);
   VA_SUCCESS_OR_RETURN(va_res, "vaEndPicture failed", false);
 
   return true;
 }
 
 bool VaapiWrapper::ExecuteAndDestroyPendingBuffers(VASurfaceID va_surface_id) {
   bool result = Execute(va_surface_id);
   DestroyPendingBuffers();
   return result;
 }
 
 #if defined(USE_X11)
 bool VaapiWrapper::PutSurfaceIntoPixmap(VASurfaceID va_surface_id,
                                         Pixmap x_pixmap,
                                         gfx::Size dest_size) {
   base::AutoLock auto_lock(*va_lock_);
 
   VAStatus va_res = vaSyncSurface(va_display_, va_surface_id);
   VA_SUCCESS_OR_RETURN(va_res, "Failed syncing surface", false);
 
   // Put the data into an X Pixmap.
-  va_res = vaPutSurface(va_display_,
-                        va_surface_id,
-                        x_pixmap,
-                        0, 0, dest_size.width(), dest_size.height(),
-                        0, 0, dest_size.width(), dest_size.height(),
-                        NULL, 0, 0);
+  va_res = vaPutSurface(va_display_, va_surface_id, x_pixmap, 0, 0,
+                        dest_size.width(), dest_size.height(), 0, 0,
+                        dest_size.width(), dest_size.height(), NULL, 0, 0);
   VA_SUCCESS_OR_RETURN(va_res, "Failed putting surface to pixmap", false);
   return true;
 }
 #endif  // USE_X11
 
 bool VaapiWrapper::GetDerivedVaImage(VASurfaceID va_surface_id,
                                      VAImage* image,
                                      void** mem) {
   base::AutoLock auto_lock(*va_lock_);
 
@@ skipping 117 matching lines @@
                                                  VASurfaceID sync_surface_id,
                                                  uint8_t* target_ptr,
                                                  size_t target_size,
                                                  size_t* coded_data_size) {
   base::AutoLock auto_lock(*va_lock_);
 
   VAStatus va_res = vaSyncSurface(va_display_, sync_surface_id);
   VA_SUCCESS_OR_RETURN(va_res, "Failed syncing surface", false);
 
   VACodedBufferSegment* buffer_segment = NULL;
-  va_res = vaMapBuffer(
-      va_display_, buffer_id, reinterpret_cast<void**>(&buffer_segment));
+  va_res = vaMapBuffer(va_display_, buffer_id,
+                       reinterpret_cast<void**>(&buffer_segment));
   VA_SUCCESS_OR_RETURN(va_res, "vaMapBuffer failed", false);
   DCHECK(target_ptr);
 
   {
     base::AutoUnlock auto_unlock(*va_lock_);
     *coded_data_size = 0;
 
     while (buffer_segment) {
       DCHECK(buffer_segment->buf);
 
@@ skipping 152 matching lines @@
   scoped_refptr<VaapiWrapper> vaapi_wrapper(new VaapiWrapper());
   if (!vaapi_wrapper->VaInitialize(base::Bind(&base::DoNothing)))
     return;
   for (size_t i = 0; i < kCodecModeMax; ++i) {
     supported_profiles_[i] =
         vaapi_wrapper->GetSupportedProfileInfosForCodecModeInternal(
             static_cast<CodecMode>(i));
   }
 }
 
-VaapiWrapper::LazyProfileInfos::~LazyProfileInfos() {
-}
+VaapiWrapper::LazyProfileInfos::~LazyProfileInfos() {}
 
 std::vector<VaapiWrapper::ProfileInfo>
 VaapiWrapper::LazyProfileInfos::GetSupportedProfileInfosForCodecMode(
     CodecMode mode) {
   return supported_profiles_[mode];
 }
 
-bool VaapiWrapper::LazyProfileInfos::IsProfileSupported(
-    CodecMode mode, VAProfile va_profile) {
+bool VaapiWrapper::LazyProfileInfos::IsProfileSupported(CodecMode mode,
+                                                        VAProfile va_profile) {
   for (const auto& profile : supported_profiles_[mode]) {
     if (profile.va_profile == va_profile)
       return true;
   }
   return false;
 }
 
 VaapiWrapper::VADisplayState::VADisplayState()
     : refcount_(0),
       va_display_(nullptr),
@@ skipping 53 matching lines @@
 }
 
 #if defined(USE_OZONE)
 void VaapiWrapper::VADisplayState::SetDrmFd(base::PlatformFile fd) {
   drm_fd_.reset(HANDLE_EINTR(dup(fd)));
 }
 #endif  // USE_OZONE
 
 bool VaapiWrapper::VADisplayState::VAAPIVersionLessThan(int major, int minor) {
   return (major_version_ < major) ||
-      (major_version_ == major && minor_version_ < minor);
+         (major_version_ == major && minor_version_ < minor);
 }
 
-}  // namespace content
+}  // namespace media