Test X11 header pollution

media/gpu/v4l2_slice_video_decode_accelerator.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/v4l2_slice_video_decode_accelerator.h"
+#include "media/gpu/v4l2_slice_video_decode_accelerator.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <string.h>
 #include <sys/eventfd.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/stringprintf.h"
-#include "content/common/gpu/media/shared_memory_region.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/media_switches.h"
+#include "media/gpu/shared_memory_region.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/scoped_binders.h"
 
 #define LOGF(level) LOG(level) << __FUNCTION__ << "(): "
 #define DVLOGF(level) DVLOG(level) << __FUNCTION__ << "(): "
 
 #define NOTIFY_ERROR(x)                        \
   do {                                         \
     LOG(ERROR) << "Setting error state:" << x; \
     SetErrorState(x);                          \
   } while (0)
 
-#define IOCTL_OR_ERROR_RETURN_VALUE(type, arg, value, type_str)           \
-  do {                                                                    \
-    if (device_->Ioctl(type, arg) != 0) {                                 \
-      PLOG(ERROR) << __FUNCTION__ << "(): ioctl() failed: " << type_str;  \
-      return value;                                                       \
-    }                                                                     \
+#define IOCTL_OR_ERROR_RETURN_VALUE(type, arg, value, type_str)          \
+  do {                                                                   \
+    if (device_->Ioctl(type, arg) != 0) {                                \
+      PLOG(ERROR) << __FUNCTION__ << "(): ioctl() failed: " << type_str; \
+      return value;                                                      \
+    }                                                                    \
   } while (0)
 
 #define IOCTL_OR_ERROR_RETURN(type, arg) \
   IOCTL_OR_ERROR_RETURN_VALUE(type, arg, ((void)0), #type)
 
 #define IOCTL_OR_ERROR_RETURN_FALSE(type, arg) \
   IOCTL_OR_ERROR_RETURN_VALUE(type, arg, false, #type)
 
 #define IOCTL_OR_LOG_ERROR(type, arg)                                 \
   do {                                                                \
     if (device_->Ioctl(type, arg) != 0)                               \
       PLOG(ERROR) << __FUNCTION__ << "(): ioctl() failed: " << #type; \
   } while (0)
 
-namespace content {
+namespace media {
 
 // static
 const uint32_t V4L2SliceVideoDecodeAccelerator::supported_input_fourccs_[] = {
     V4L2_PIX_FMT_H264_SLICE, V4L2_PIX_FMT_VP8_FRAME,
 };
 
 class V4L2SliceVideoDecodeAccelerator::V4L2DecodeSurface
     : public base::RefCounted<V4L2DecodeSurface> {
  public:
   using ReleaseCB = base::Callback<void(int)>;
@@ skipping 79 matching lines @@
     base::StringAppendF(&out, " %d", ref->output_record());
   }
   return out;
 }
 
 V4L2SliceVideoDecodeAccelerator::InputRecord::InputRecord()
     : input_id(-1),
       address(nullptr),
       length(0),
       bytes_used(0),
-      at_device(false) {
-}
+      at_device(false) {}
 
 V4L2SliceVideoDecodeAccelerator::OutputRecord::OutputRecord()
     : at_device(false),
       at_client(false),
       picture_id(-1),
       texture_id(0),
       egl_image(EGL_NO_IMAGE_KHR),
       egl_sync(EGL_NO_SYNC_KHR),
       cleared(false) {}
 
@@ skipping 35 matching lines @@
 struct V4L2SliceVideoDecodeAccelerator::EGLSyncKHRRef {
   EGLSyncKHRRef(EGLDisplay egl_display, EGLSyncKHR egl_sync);
   ~EGLSyncKHRRef();
   EGLDisplay const egl_display;
   EGLSyncKHR egl_sync;
 };
 
 V4L2SliceVideoDecodeAccelerator::EGLSyncKHRRef::EGLSyncKHRRef(
     EGLDisplay egl_display,
     EGLSyncKHR egl_sync)
-    : egl_display(egl_display), egl_sync(egl_sync) {
-}
+    : egl_display(egl_display), egl_sync(egl_sync) {}
 
 V4L2SliceVideoDecodeAccelerator::EGLSyncKHRRef::~EGLSyncKHRRef() {
   // We don't check for eglDestroySyncKHR failures, because if we get here
   // with a valid sync object, something went wrong and we are getting
   // destroyed anyway.
   if (egl_sync != EGL_NO_SYNC_KHR)
     eglDestroySyncKHR(egl_display, egl_sync);
 }
 
 struct V4L2SliceVideoDecodeAccelerator::PictureRecord {
   PictureRecord(bool cleared, const media::Picture& picture);
   ~PictureRecord();
   bool cleared;  // Whether the texture is cleared and safe to render from.
   media::Picture picture;  // The decoded picture.
 };
 
 V4L2SliceVideoDecodeAccelerator::PictureRecord::PictureRecord(
     bool cleared,
     const media::Picture& picture)
-    : cleared(cleared), picture(picture) {
-}
+    : cleared(cleared), picture(picture) {}
 
-V4L2SliceVideoDecodeAccelerator::PictureRecord::~PictureRecord() {
-}
+V4L2SliceVideoDecodeAccelerator::PictureRecord::~PictureRecord() {}
 
 class V4L2SliceVideoDecodeAccelerator::V4L2H264Accelerator
     : public H264Decoder::H264Accelerator {
  public:
   V4L2H264Accelerator(V4L2SliceVideoDecodeAccelerator* v4l2_dec);
   ~V4L2H264Accelerator() override;
 
   // H264Decoder::H264Accelerator implementation.
   scoped_refptr<H264Picture> CreateH264Picture() override;
 
@@ skipping 65 matching lines @@
 
   V4L2SliceVideoDecodeAccelerator* v4l2_dec_;
 
   DISALLOW_COPY_AND_ASSIGN(V4L2VP8Accelerator);
 };
 
 // Codec-specific subclasses of software decoder picture classes.
 // This allows us to keep decoders oblivious of our implementation details.
 class V4L2H264Picture : public H264Picture {
  public:
-  V4L2H264Picture(const scoped_refptr<
-      V4L2SliceVideoDecodeAccelerator::V4L2DecodeSurface>& dec_surface);
+  V4L2H264Picture(
+      const scoped_refptr<V4L2SliceVideoDecodeAccelerator::V4L2DecodeSurface>&
+          dec_surface);
 
   V4L2H264Picture* AsV4L2H264Picture() override { return this; }
   scoped_refptr<V4L2SliceVideoDecodeAccelerator::V4L2DecodeSurface>
   dec_surface() {
     return dec_surface_;
   }
 
  private:
   ~V4L2H264Picture() override;
 
   scoped_refptr<V4L2SliceVideoDecodeAccelerator::V4L2DecodeSurface>
       dec_surface_;
 
   DISALLOW_COPY_AND_ASSIGN(V4L2H264Picture);
 };
 
-V4L2H264Picture::V4L2H264Picture(const scoped_refptr<
-    V4L2SliceVideoDecodeAccelerator::V4L2DecodeSurface>& dec_surface)
-    : dec_surface_(dec_surface) {
-}
+V4L2H264Picture::V4L2H264Picture(
+    const scoped_refptr<V4L2SliceVideoDecodeAccelerator::V4L2DecodeSurface>&
+        dec_surface)
+    : dec_surface_(dec_surface) {}
 
-V4L2H264Picture::~V4L2H264Picture() {
-}
+V4L2H264Picture::~V4L2H264Picture() {}
 
 class V4L2VP8Picture : public VP8Picture {
  public:
-  V4L2VP8Picture(const scoped_refptr<
-      V4L2SliceVideoDecodeAccelerator::V4L2DecodeSurface>& dec_surface);
+  V4L2VP8Picture(
+      const scoped_refptr<V4L2SliceVideoDecodeAccelerator::V4L2DecodeSurface>&
+          dec_surface);
 
   V4L2VP8Picture* AsV4L2VP8Picture() override { return this; }
   scoped_refptr<V4L2SliceVideoDecodeAccelerator::V4L2DecodeSurface>
   dec_surface() {
     return dec_surface_;
   }
 
  private:
   ~V4L2VP8Picture() override;
 
   scoped_refptr<V4L2SliceVideoDecodeAccelerator::V4L2DecodeSurface>
       dec_surface_;
 
   DISALLOW_COPY_AND_ASSIGN(V4L2VP8Picture);
 };
 
-V4L2VP8Picture::V4L2VP8Picture(const scoped_refptr<
-    V4L2SliceVideoDecodeAccelerator::V4L2DecodeSurface>& dec_surface)
-    : dec_surface_(dec_surface) {
-}
+V4L2VP8Picture::V4L2VP8Picture(
+    const scoped_refptr<V4L2SliceVideoDecodeAccelerator::V4L2DecodeSurface>&
+        dec_surface)
+    : dec_surface_(dec_surface) {}
 
-V4L2VP8Picture::~V4L2VP8Picture() {
-}
+V4L2VP8Picture::~V4L2VP8Picture() {}
 
 V4L2SliceVideoDecodeAccelerator::V4L2SliceVideoDecodeAccelerator(
     const scoped_refptr<V4L2Device>& device,
     EGLDisplay egl_display,
     const GetGLContextCallback& get_gl_context_cb,
     const MakeGLContextCurrentCallback& make_context_current_cb)
     : input_planes_count_(0),
       output_planes_count_(0),
       child_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       device_(device),
@@ skipping 117 matching lines @@
   } else {
     DVLOG(1) << "No GL callbacks provided, initializing without GL support";
   }
 
   // Capabilities check.
   struct v4l2_capability caps;
   const __u32 kCapsRequired = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_STREAMING;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYCAP, &caps);
   if ((caps.capabilities & kCapsRequired) != kCapsRequired) {
     LOG(ERROR) << "Initialize(): ioctl() failed: VIDIOC_QUERYCAP"
-                  ", caps check failed: 0x" << std::hex << caps.capabilities;
+                  ", caps check failed: 0x"
+               << std::hex << caps.capabilities;
     return false;
   }
 
   if (!SetupFormats())
     return false;
 
   if (!decoder_thread_.Start()) {
     DLOG(ERROR) << "Initialize(): device thread failed to start";
     return false;
   }
@@ skipping 163 matching lines @@
     struct v4l2_plane planes[VIDEO_MAX_PLANES];
     struct v4l2_buffer buffer;
     memset(&buffer, 0, sizeof(buffer));
     memset(planes, 0, sizeof(planes));
     buffer.index = i;
     buffer.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
     buffer.memory = V4L2_MEMORY_MMAP;
     buffer.m.planes = planes;
     buffer.length = input_planes_count_;
     IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYBUF, &buffer);
-    void* address = device_->Mmap(nullptr,
-                                  buffer.m.planes[0].length,
-                                  PROT_READ | PROT_WRITE,
-                                  MAP_SHARED,
+    void* address = device_->Mmap(nullptr, buffer.m.planes[0].length,
+                                  PROT_READ | PROT_WRITE, MAP_SHARED,
                                   buffer.m.planes[0].m.mem_offset);
     if (address == MAP_FAILED) {
       PLOG(ERROR) << "CreateInputBuffers(): mmap() failed";
       return false;
     }
     input_buffer_map_[i].address = address;
     input_buffer_map_[i].length = buffer.m.planes[0].length;
   }
 
   return true;
@@ skipping 138 matching lines @@
   }
 
   DVLOGF(4) << "Scheduling device poll task";
 
   device_poll_thread_.message_loop()->PostTask(
       FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::DevicePollTask,
                             base::Unretained(this), true));
 
   DVLOGF(2) << "buffer counts: "
             << "INPUT[" << decoder_input_queue_.size() << "]"
-            << " => DEVICE["
-            << free_input_buffers_.size() << "+"
-            << input_buffer_queued_count_ << "/"
-            << input_buffer_map_.size() << "]->["
-            << free_output_buffers_.size() << "+"
-            << output_buffer_queued_count_ << "/"
-            << output_buffer_map_.size() << "]"
+            << " => DEVICE[" << free_input_buffers_.size() << "+"
+            << input_buffer_queued_count_ << "/" << input_buffer_map_.size()
+            << "]->[" << free_output_buffers_.size() << "+"
+            << output_buffer_queued_count_ << "/" << output_buffer_map_.size()
+            << "]"
             << " => DISPLAYQ[" << decoder_display_queue_.size() << "]"
             << " => CLIENT[" << surfaces_at_display_.size() << "]";
 }
 
 void V4L2SliceVideoDecodeAccelerator::Enqueue(
     const scoped_refptr<V4L2DecodeSurface>& dec_surface) {
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   const int old_inputs_queued = input_buffer_queued_count_;
   const int old_outputs_queued = output_buffer_queued_count_;
 
   if (!EnqueueInputRecord(dec_surface->input_record(),
                           dec_surface->config_store())) {
     DVLOGF(1) << "Failed queueing an input buffer";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
 
   if (!EnqueueOutputRecord(dec_surface->output_record())) {
     DVLOGF(1) << "Failed queueing an output buffer";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
 
   bool inserted =
-      surfaces_at_device_.insert(std::make_pair(dec_surface->output_record(),
-                                                dec_surface)).second;
+      surfaces_at_device_
+          .insert(std::make_pair(dec_surface->output_record(), dec_surface))
+          .second;
   DCHECK(inserted);
 
   if (old_inputs_queued == 0 && old_outputs_queued == 0)
     SchedulePollIfNeeded();
 }
 
 void V4L2SliceVideoDecodeAccelerator::Dequeue() {
   DVLOGF(3);
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
@@ skipping 41 matching lines @@
         break;
       }
       PLOG(ERROR) << "ioctl() failed: VIDIOC_DQBUF";
       NOTIFY_ERROR(PLATFORM_FAILURE);
       return;
     }
     OutputRecord& output_record = output_buffer_map_[dqbuf.index];
     DCHECK(output_record.at_device);
     output_record.at_device = false;
     output_buffer_queued_count_--;
-    DVLOGF(3) << "Dequeued output=" << dqbuf.index
-              << " count " << output_buffer_queued_count_;
+    DVLOGF(3) << "Dequeued output=" << dqbuf.index << " count "
+              << output_buffer_queued_count_;
 
     V4L2DecodeSurfaceByOutputId::iterator it =
         surfaces_at_device_.find(dqbuf.index);
     if (it == surfaces_at_device_.end()) {
       DLOG(ERROR) << "Got invalid surface from device.";
       NOTIFY_ERROR(PLATFORM_FAILURE);
     }
 
     it->second->SetDecoded();
     surfaces_at_device_.erase(it);
@@ skipping 52 matching lines @@
   DVLOGF(4) << "Reusing input buffer, index=" << index;
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   DCHECK_LT(index, static_cast<int>(input_buffer_map_.size()));
   InputRecord& input_record = input_buffer_map_[index];
 
   DCHECK(!input_record.at_device);
   input_record.input_id = -1;
   input_record.bytes_used = 0;
 
-  DCHECK_EQ(std::count(free_input_buffers_.begin(), free_input_buffers_.end(),
-            index), 0);
+  DCHECK_EQ(
+      std::count(free_input_buffers_.begin(), free_input_buffers_.end(), index),
+      0);
   free_input_buffers_.push_back(index);
 }
 
 void V4L2SliceVideoDecodeAccelerator::ReuseOutputBuffer(int index) {
   DVLOGF(4) << "Reusing output buffer, index=" << index;
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   DCHECK_LT(index, static_cast<int>(output_buffer_map_.size()));
   OutputRecord& output_record = output_buffer_map_[index];
   DCHECK(!output_record.at_device);
   DCHECK(!output_record.at_client);
 
   DCHECK_EQ(std::count(free_output_buffers_.begin(), free_output_buffers_.end(),
-            index), 0);
+                       index),
+            0);
   free_output_buffers_.push_back(index);
 
   ScheduleDecodeBufferTaskIfNeeded();
 }
 
 bool V4L2SliceVideoDecodeAccelerator::EnqueueInputRecord(
     int index,
     uint32_t config_store) {
   DVLOGF(3);
   DCHECK_LT(index, static_cast<int>(input_buffer_map_.size()));
@@ skipping 440 matching lines @@
 void V4L2SliceVideoDecodeAccelerator::AssignPictureBuffersTask(
     const std::vector<media::PictureBuffer>& buffers) {
   DVLOGF(3);
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kAwaitingPictureBuffers);
 
   const uint32_t req_buffer_count = decoder_->GetRequiredNumOfPictures();
 
   if (buffers.size() < req_buffer_count) {
     DLOG(ERROR) << "Failed to provide requested picture buffers. "
-                << "(Got " << buffers.size()
-                << ", requested " << req_buffer_count << ")";
+                << "(Got " << buffers.size() << ", requested "
+                << req_buffer_count << ")";
     NOTIFY_ERROR(INVALID_ARGUMENT);
     return;
   }
 
   // Allocate the output buffers.
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = buffers.size();
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   reqbufs.memory =
@@ skipping 466 matching lines @@
 
   state_ = kError;
 }
 
 V4L2SliceVideoDecodeAccelerator::V4L2H264Accelerator::V4L2H264Accelerator(
     V4L2SliceVideoDecodeAccelerator* v4l2_dec)
     : num_slices_(0), v4l2_dec_(v4l2_dec) {
   DCHECK(v4l2_dec_);
 }
 
-V4L2SliceVideoDecodeAccelerator::V4L2H264Accelerator::~V4L2H264Accelerator() {
-}
+V4L2SliceVideoDecodeAccelerator::V4L2H264Accelerator::~V4L2H264Accelerator() {}
 
 scoped_refptr<H264Picture>
 V4L2SliceVideoDecodeAccelerator::V4L2H264Accelerator::CreateH264Picture() {
   scoped_refptr<V4L2DecodeSurface> dec_surface = v4l2_dec_->CreateSurface();
   if (!dec_surface)
     return nullptr;
 
   return new V4L2H264Picture(dec_surface);
 }
 
@@ skipping 47 matching lines @@
     const H264Picture::Vector& ref_pic_listp0,
     const H264Picture::Vector& ref_pic_listb0,
     const H264Picture::Vector& ref_pic_listb1,
     const scoped_refptr<H264Picture>& pic) {
   struct v4l2_ext_control ctrl;
   std::vector<struct v4l2_ext_control> ctrls;
 
   struct v4l2_ctrl_h264_sps v4l2_sps;
   memset(&v4l2_sps, 0, sizeof(v4l2_sps));
   v4l2_sps.constraint_set_flags =
-    sps->constraint_set0_flag ? V4L2_H264_SPS_CONSTRAINT_SET0_FLAG : 0 |
-    sps->constraint_set1_flag ? V4L2_H264_SPS_CONSTRAINT_SET1_FLAG : 0 |
-    sps->constraint_set2_flag ? V4L2_H264_SPS_CONSTRAINT_SET2_FLAG : 0 |
-    sps->constraint_set3_flag ? V4L2_H264_SPS_CONSTRAINT_SET3_FLAG : 0 |
-    sps->constraint_set4_flag ? V4L2_H264_SPS_CONSTRAINT_SET4_FLAG : 0 |
-    sps->constraint_set5_flag ? V4L2_H264_SPS_CONSTRAINT_SET5_FLAG : 0;
+      sps->constraint_set0_flag
+          ? V4L2_H264_SPS_CONSTRAINT_SET0_FLAG
+          : 0 | sps->constraint_set1_flag
+                ? V4L2_H264_SPS_CONSTRAINT_SET1_FLAG
+                : 0 | sps->constraint_set2_flag
+                      ? V4L2_H264_SPS_CONSTRAINT_SET2_FLAG
+                      : 0 | sps->constraint_set3_flag
+                            ? V4L2_H264_SPS_CONSTRAINT_SET3_FLAG
+                            : 0 | sps->constraint_set4_flag
+                                  ? V4L2_H264_SPS_CONSTRAINT_SET4_FLAG
+                                  : 0 | sps->constraint_set5_flag
+                                        ? V4L2_H264_SPS_CONSTRAINT_SET5_FLAG
+                                        : 0;
 #define SPS_TO_V4L2SPS(a) v4l2_sps.a = sps->a
   SPS_TO_V4L2SPS(profile_idc);
   SPS_TO_V4L2SPS(level_idc);
   SPS_TO_V4L2SPS(seq_parameter_set_id);
   SPS_TO_V4L2SPS(chroma_format_idc);
   SPS_TO_V4L2SPS(bit_depth_luma_minus8);
   SPS_TO_V4L2SPS(bit_depth_chroma_minus8);
   SPS_TO_V4L2SPS(log2_max_frame_num_minus4);
   SPS_TO_V4L2SPS(pic_order_cnt_type);
   SPS_TO_V4L2SPS(log2_max_pic_order_cnt_lsb_minus4);
   SPS_TO_V4L2SPS(offset_for_non_ref_pic);
   SPS_TO_V4L2SPS(offset_for_top_to_bottom_field);
   SPS_TO_V4L2SPS(num_ref_frames_in_pic_order_cnt_cycle);
 
   static_assert(arraysize(v4l2_sps.offset_for_ref_frame) ==
-                arraysize(sps->offset_for_ref_frame),
+                    arraysize(sps->offset_for_ref_frame),
                 "offset_for_ref_frame arrays must be same size");
   for (size_t i = 0; i < arraysize(v4l2_sps.offset_for_ref_frame); ++i)
     v4l2_sps.offset_for_ref_frame[i] = sps->offset_for_ref_frame[i];
   SPS_TO_V4L2SPS(max_num_ref_frames);
   SPS_TO_V4L2SPS(pic_width_in_mbs_minus1);
   SPS_TO_V4L2SPS(pic_height_in_map_units_minus1);
 #undef SPS_TO_V4L2SPS
 
 #define SET_V4L2_SPS_FLAG_IF(cond, flag) \
   v4l2_sps.flags |= ((sps->cond) ? (flag) : 0)
@@ skipping 53 matching lines @@
 #undef SET_V4L2_PPS_FLAG_IF
   memset(&ctrl, 0, sizeof(ctrl));
   ctrl.id = V4L2_CID_MPEG_VIDEO_H264_PPS;
   ctrl.size = sizeof(v4l2_pps);
   ctrl.p_h264_pps = &v4l2_pps;
   ctrls.push_back(ctrl);
 
   struct v4l2_ctrl_h264_scaling_matrix v4l2_scaling_matrix;
   memset(&v4l2_scaling_matrix, 0, sizeof(v4l2_scaling_matrix));
   static_assert(arraysize(v4l2_scaling_matrix.scaling_list_4x4) <=
-                arraysize(pps->scaling_list4x4) &&
-                arraysize(v4l2_scaling_matrix.scaling_list_4x4[0]) <=
-                arraysize(pps->scaling_list4x4[0]) &&
-                arraysize(v4l2_scaling_matrix.scaling_list_8x8) <=
-                arraysize(pps->scaling_list8x8) &&
-                arraysize(v4l2_scaling_matrix.scaling_list_8x8[0]) <=
-                arraysize(pps->scaling_list8x8[0]),
+                        arraysize(pps->scaling_list4x4) &&
+                    arraysize(v4l2_scaling_matrix.scaling_list_4x4[0]) <=
+                        arraysize(pps->scaling_list4x4[0]) &&
+                    arraysize(v4l2_scaling_matrix.scaling_list_8x8) <=
+                        arraysize(pps->scaling_list8x8) &&
+                    arraysize(v4l2_scaling_matrix.scaling_list_8x8[0]) <=
+                        arraysize(pps->scaling_list8x8[0]),
                 "scaling_lists must be of correct size");
   for (size_t i = 0; i < arraysize(v4l2_scaling_matrix.scaling_list_4x4); ++i) {
     for (size_t j = 0; j < arraysize(v4l2_scaling_matrix.scaling_list_4x4[i]);
          ++j) {
       v4l2_scaling_matrix.scaling_list_4x4[i][j] = pps->scaling_list4x4[i][j];
     }
   }
   for (size_t i = 0; i < arraysize(v4l2_scaling_matrix.scaling_list_8x8); ++i) {
     for (size_t j = 0; j < arraysize(v4l2_scaling_matrix.scaling_list_8x8[i]);
          ++j) {
@@ skipping 236 matching lines @@
   CHECK(v4l2_pic);
   return v4l2_pic->dec_surface();
 }
 
 V4L2SliceVideoDecodeAccelerator::V4L2VP8Accelerator::V4L2VP8Accelerator(
     V4L2SliceVideoDecodeAccelerator* v4l2_dec)
     : v4l2_dec_(v4l2_dec) {
   DCHECK(v4l2_dec_);
 }
 
-V4L2SliceVideoDecodeAccelerator::V4L2VP8Accelerator::~V4L2VP8Accelerator() {
-}
+V4L2SliceVideoDecodeAccelerator::V4L2VP8Accelerator::~V4L2VP8Accelerator() {}
 
 scoped_refptr<VP8Picture>
 V4L2SliceVideoDecodeAccelerator::V4L2VP8Accelerator::CreateVP8Picture() {
   scoped_refptr<V4L2DecodeSurface> dec_surface = v4l2_dec_->CreateSurface();
   if (!dec_surface)
     return nullptr;
 
   return new V4L2VP8Picture(dec_surface);
 }
 
@@ skipping 61 matching lines @@
 
 static void FillV4L2EntropyHeader(
     const media::Vp8EntropyHeader& vp8_entropy_hdr,
     struct v4l2_vp8_entropy_hdr* v4l2_entropy_hdr) {
   ARRAY_MEMCPY_CHECKED(v4l2_entropy_hdr->coeff_probs,
                        vp8_entropy_hdr.coeff_probs);
   ARRAY_MEMCPY_CHECKED(v4l2_entropy_hdr->y_mode_probs,
                        vp8_entropy_hdr.y_mode_probs);
   ARRAY_MEMCPY_CHECKED(v4l2_entropy_hdr->uv_mode_probs,
                        vp8_entropy_hdr.uv_mode_probs);
-  ARRAY_MEMCPY_CHECKED(v4l2_entropy_hdr->mv_probs,
-                       vp8_entropy_hdr.mv_probs);
+  ARRAY_MEMCPY_CHECKED(v4l2_entropy_hdr->mv_probs, vp8_entropy_hdr.mv_probs);
 }
 
 bool V4L2SliceVideoDecodeAccelerator::V4L2VP8Accelerator::SubmitDecode(
     const scoped_refptr<VP8Picture>& pic,
     const media::Vp8FrameHeader* frame_hdr,
     const scoped_refptr<VP8Picture>& last_frame,
     const scoped_refptr<VP8Picture>& golden_frame,
     const scoped_refptr<VP8Picture>& alt_frame) {
   struct v4l2_ctrl_vp8_frame_hdr v4l2_frame_hdr;
   memset(&v4l2_frame_hdr, 0, sizeof(v4l2_frame_hdr));
@@ skipping 37 matching lines @@
 
   v4l2_frame_hdr.first_part_size =
       base::checked_cast<__u32>(frame_hdr->first_part_size);
   v4l2_frame_hdr.first_part_offset =
       base::checked_cast<__u32>(frame_hdr->first_part_offset);
   v4l2_frame_hdr.macroblock_bit_offset =
       base::checked_cast<__u32>(frame_hdr->macroblock_bit_offset);
   v4l2_frame_hdr.num_dct_parts = frame_hdr->num_of_dct_partitions;
 
   static_assert(arraysize(v4l2_frame_hdr.dct_part_sizes) ==
-                arraysize(frame_hdr->dct_partition_sizes),
+                    arraysize(frame_hdr->dct_partition_sizes),
                 "DCT partition size arrays must have equal number of elements");
   for (size_t i = 0; i < frame_hdr->num_of_dct_partitions &&
-       i < arraysize(v4l2_frame_hdr.dct_part_sizes); ++i)
+                     i < arraysize(v4l2_frame_hdr.dct_part_sizes);
+       ++i)
     v4l2_frame_hdr.dct_part_sizes[i] = frame_hdr->dct_partition_sizes[i];
 
   scoped_refptr<V4L2DecodeSurface> dec_surface =
       VP8PictureToV4L2DecodeSurface(pic);
   std::vector<scoped_refptr<V4L2DecodeSurface>> ref_surfaces;
 
   if (last_frame) {
     scoped_refptr<V4L2DecodeSurface> last_frame_surface =
         VP8PictureToV4L2DecodeSurface(last_frame);
     v4l2_frame_hdr.last_frame = last_frame_surface->output_record();
@@ skipping 93 matching lines @@
 }
 
 void V4L2SliceVideoDecodeAccelerator::OutputSurface(
     const scoped_refptr<V4L2DecodeSurface>& dec_surface) {
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   OutputRecord& output_record =
       output_buffer_map_[dec_surface->output_record()];
 
   bool inserted =
-      surfaces_at_display_.insert(std::make_pair(output_record.picture_id,
-                                                 dec_surface)).second;
+      surfaces_at_display_
+          .insert(std::make_pair(output_record.picture_id, dec_surface))
+          .second;
   DCHECK(inserted);
 
   DCHECK(!output_record.at_client);
   DCHECK(!output_record.at_device);
   DCHECK_NE(output_record.picture_id, -1);
   output_record.at_client = true;
 
   // TODO(posciak): Use visible size from decoder here instead
   // (crbug.com/402760). Passing (0, 0) results in the client using the
   // visible size extracted from the container instead.
@@ skipping 105 matching lines @@
 media::VideoDecodeAccelerator::SupportedProfiles
 V4L2SliceVideoDecodeAccelerator::GetSupportedProfiles() {
   scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kDecoder);
   if (!device)
     return SupportedProfiles();
 
   return device->GetSupportedDecodeProfiles(arraysize(supported_input_fourccs_),
                                             supported_input_fourccs_);
 }
 
-}  // namespace content
+}  // namespace media