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

media/gpu/v4l2_video_encode_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_encode_accelerator.h"
 
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <string.h>
@@ skipping 114 matching lines @@
 
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(encoder_state_, kUninitialized);
 
   struct v4l2_capability caps;
   memset(&caps, 0, sizeof(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 (!SetFormats(input_format, output_profile)) {
     DLOG(ERROR) << "Failed setting up formats";
     return false;
   }
 
   if (input_format != device_input_format_) {
     DVLOG(1) << "Input format not supported by the HW, will convert to "
@@ skipping 360 matching lines @@
   // * device_poll_thread_ is running normally
   // * device_poll_thread_ scheduled us, but then a DestroyTask() shut it down,
   //   in which case we're in kError state, 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(&V4L2VideoEncodeAccelerator::DevicePollTask,
                             base::Unretained(this), poll_device));
 
-  DVLOG(2) << __func__ << ": buffer counts: ENC[" << encoder_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()
-           << "] => OUT[" << encoder_output_queue_.size() << "]";
+  DVLOG(2) << __func__ << ": buffer counts: ENC["
+           << encoder_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() << "] => OUT["
+           << encoder_output_queue_.size() << "]";
 }
 
 void V4L2VideoEncodeAccelerator::Enqueue() {
   DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
 
   DVLOG(3) << "Enqueue() "
            << "free_input_buffers: " << free_input_buffers_.size()
            << "input_queue: " << encoder_input_queue_.size();
 
   // Enqueue all the inputs we can.
@@ skipping 118 matching lines @@
         memcpy(target_data + stream_header_size_, output_data, output_size);
         output_size += stream_header_size_;
       } else {
         memcpy(target_data, output_data, output_size);
       }
     } else {
       memcpy(target_data, output_data, output_size);
     }
 
     DVLOG(3) << "Dequeue(): returning "
-                "bitstream_buffer_id="
-             << output_record.buffer_ref->id << ", size=" << output_size
+             << "bitstream_buffer_id=" << output_record.buffer_ref->id
+             << ", size=" << output_size
              << ", key_frame=" << key_frame;
     child_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&Client::BitstreamBufferReady, client_,
                    output_record.buffer_ref->id, output_size, key_frame));
     output_record.at_device = false;
     output_record.buffer_ref.reset();
     free_output_buffers_.push_back(dqbuf.index);
     output_buffer_queued_count_--;
   }
@@ skipping 517 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_CAPTURE_MPLANE;
     buffer.memory = V4L2_MEMORY_MMAP;
     buffer.m.planes = planes;
     buffer.length = arraysize(planes);
     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) << "CreateOutputBuffers(): mmap() failed";
       return false;
     }
     output_buffer_map_[i].address = address;
     output_buffer_map_[i].length = buffer.m.planes[0].length;
     free_output_buffers_.push_back(i);
   }
 
   return true;
@@ skipping 31 matching lines @@
   reqbufs.count = 0;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
 
   output_buffer_map_.clear();
   free_output_buffers_.clear();
 }
 
 }  // namespace media