media/gpu: restore some of the reformatting done during migration to media/gpu.

media/gpu/v4l2_video_decode_accelerator.cc

 // Copyright 2014 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 "media/gpu/v4l2_video_decode_accelerator.h"
 
 #include <dlfcn.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
@@ skipping 240 matching lines @@
     return false;
   }
 #endif
 
   // 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;
 
   // Subscribe to the resolution change event.
   struct v4l2_event_subscription sub;
   memset(&sub, 0, sizeof(sub));
   sub.type = V4L2_EVENT_SOURCE_CHANGE;
@@ skipping 46 matching lines @@
 void V4L2VideoDecodeAccelerator::AssignPictureBuffers(
     const std::vector<media::PictureBuffer>& buffers) {
   DVLOG(3) << "AssignPictureBuffers(): buffer_count=" << buffers.size();
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   const uint32_t req_buffer_count =
       output_dpb_size_ + kDpbOutputBufferExtraCount;
 
   if (buffers.size() < req_buffer_count) {
     LOG(ERROR) << "AssignPictureBuffers(): Failed to provide requested picture"
-                  " buffers. (Got "
-               << buffers.size() << ", requested " << req_buffer_count << ")";
+               << " buffers. (Got " << buffers.size()
+               << ", requested " << req_buffer_count << ")";
     NOTIFY_ERROR(INVALID_ARGUMENT);
     return;
   }
 
   gfx::GLContext* gl_context = get_gl_context_cb_.Run();
   if (!gl_context || !make_context_current_cb_.Run()) {
     LOG(ERROR) << "AssignPictureBuffers(): could not make context current";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
@@ skipping 663 matching lines @@
   // * device_poll_thread_ scheduled us, but then a ResetTask() or DestroyTask()
   //   shut it down, in which case we're either in kResetting or kError states
   //   respectively, and we should have early-outed already.
   DCHECK(device_poll_thread_.message_loop());
   // Queue the DevicePollTask() now.
   device_poll_thread_.message_loop()->PostTask(
       FROM_HERE, base::Bind(&V4L2VideoDecodeAccelerator::DevicePollTask,
                             base::Unretained(this), poll_device));
 
   DVLOG(1) << "ServiceDeviceTask(): buffer counts: DEC["
-           << decoder_input_queue_.size() << "->" << input_ready_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()
-           << "] => PROCESSOR[" << image_processor_bitstream_buffer_ids_.size()
-           << "] => CLIENT[" << decoder_frames_at_client_ << "]";
+           << decoder_input_queue_.size() << "->"
+           << input_ready_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() << "] => PROCESSOR["
+           << image_processor_bitstream_buffer_ids_.size() << "] => CLIENT["
+           << decoder_frames_at_client_ << "]";
 
   ScheduleDecodeBufferTaskIfNeeded();
   if (resolution_change_pending)
     StartResolutionChange();
 }
 
 void V4L2VideoDecodeAccelerator::Enqueue() {
   DVLOG(3) << "Enqueue()";
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
   DCHECK_NE(decoder_state_, kUninitialized);
@@ skipping 831 matching lines @@
     struct v4l2_plane planes[1];
     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 = 1;
     IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYBUF, &buffer);
-    void* address =
-        device_->Mmap(NULL, buffer.m.planes[0].length, PROT_READ | PROT_WRITE,
-                      MAP_SHARED, buffer.m.planes[0].m.mem_offset);
+    void* address = device_->Mmap(NULL,
+                                  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 354 matching lines @@
     Enqueue();
   }
 }
 
 void V4L2VideoDecodeAccelerator::ImageProcessorError() {
   LOG(ERROR) << "Image processor error";
   NOTIFY_ERROR(PLATFORM_FAILURE);
 }
 
 }  // namespace media