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

media/gpu/jpeg_decode_accelerator_unittest.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.
 
 // This has to be included first.
 // See http://code.google.com/p/googletest/issues/detail?id=371
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 159 matching lines @@
   }
   if (g_save_to_file) {
     SaveToFile(bitstream_buffer_id);
   }
 
   double difference = GetMeanAbsoluteDifference(bitstream_buffer_id);
   if (difference <= kDecodeSimilarityThreshold) {
     SetState(CS_DECODE_PASS);
   } else {
     LOG(ERROR) << "The mean absolute difference between software and hardware "
-                  "decode is "
-               << difference;
+               << "decode is " << difference;
     SetState(CS_ERROR);
   }
 }
 
 void JpegClient::NotifyError(int32_t bitstream_buffer_id,
                              JpegDecodeAccelerator::Error error) {
   LOG(ERROR) << "Notifying of error " << error << " for buffer id "
              << bitstream_buffer_id;
   SetState(CS_ERROR);
 }
@@ skipping 56 matching lines @@
   TestImageFile* image_file = test_image_files_[bitstream_buffer_id];
 
   PrepareMemory(bitstream_buffer_id);
 
   base::SharedMemoryHandle dup_handle;
   dup_handle = base::SharedMemory::DuplicateHandle(in_shm_->handle());
   media::BitstreamBuffer bitstream_buffer(bitstream_buffer_id, dup_handle,
                                           image_file->data_str.size());
   scoped_refptr<media::VideoFrame> out_frame_ =
       media::VideoFrame::WrapExternalSharedMemory(
-          media::PIXEL_FORMAT_I420, image_file->visible_size,
-          gfx::Rect(image_file->visible_size), image_file->visible_size,
-          static_cast<uint8_t*>(hw_out_shm_->memory()), image_file->output_size,
-          hw_out_shm_->handle(), 0, base::TimeDelta());
+          media::PIXEL_FORMAT_I420,

[kcwu, 2016/05/12 09:42:42]

How about add comments at the end of each line?
It's good to have comments because there are too many parameters for this call.
And it also preserve the layout as side effect.

media::PIXEL_FORMAT_I420,  // format
image_file->visible_size,  // coded size
gfx::Rect(image_file->visible_size),  // visible rectangle
etc.

[Pawel Osciak, 2016/05/13 06:07:22]

Thanks for the suggestion, on the other hand, it may be making the code a bit
verbose, so we agreed to keep as is for now.

+          image_file->visible_size,
+          gfx::Rect(image_file->visible_size),
+          image_file->visible_size,
+          static_cast<uint8_t*>(hw_out_shm_->memory()),
+          image_file->output_size,
+          hw_out_shm_->handle(),
+          0,
+          base::TimeDelta());
   LOG_ASSERT(out_frame_.get());
   decoder_->Decode(bitstream_buffer, out_frame_);
 }
 
 bool JpegClient::GetSoftwareDecodeResult(int32_t bitstream_buffer_id) {
   media::VideoPixelFormat format = media::PIXEL_FORMAT_I420;
   TestImageFile* image_file = test_image_files_[bitstream_buffer_id];
 
   uint8_t* yplane = static_cast<uint8_t*>(sw_out_shm_->memory());
   uint8_t* uplane =
       yplane +
       media::VideoFrame::PlaneSize(format, media::VideoFrame::kYPlane,
                                    image_file->visible_size)
           .GetArea();
   uint8_t* vplane =
       uplane +
       media::VideoFrame::PlaneSize(format, media::VideoFrame::kUPlane,
                                    image_file->visible_size)
           .GetArea();
   int yplane_stride = image_file->visible_size.width();
   int uv_plane_stride = yplane_stride / 2;
 
   if (libyuv::ConvertToI420(
-          static_cast<uint8_t*>(in_shm_->memory()), image_file->data_str.size(),
-          yplane, yplane_stride, uplane, uv_plane_stride, vplane,
-          uv_plane_stride, 0, 0, image_file->visible_size.width(),
-          image_file->visible_size.height(), image_file->visible_size.width(),
-          image_file->visible_size.height(), libyuv::kRotate0,
+          static_cast<uint8_t*>(in_shm_->memory()),
+          image_file->data_str.size(),
+          yplane,
+          yplane_stride,
+          uplane,
+          uv_plane_stride,
+          vplane,
+          uv_plane_stride,
+          0,
+          0,
+          image_file->visible_size.width(),
+          image_file->visible_size.height(),
+          image_file->visible_size.width(),
+          image_file->visible_size.height(),
+          libyuv::kRotate0,
           libyuv::FOURCC_MJPG) != 0) {
     LOG(ERROR) << "Software decode " << image_file->filename << " failed.";
     return false;
   }
   return true;
 }
 
 class JpegDecodeAcceleratorTestEnvironment : public ::testing::Environment {
  public:
   JpegDecodeAcceleratorTestEnvironment(
@@ skipping 264 matching lines @@
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
   media::VaapiWrapper::PreSandboxInitialization();
 #endif
 
   media::g_env = reinterpret_cast<media::JpegDecodeAcceleratorTestEnvironment*>(
       testing::AddGlobalTestEnvironment(
           new media::JpegDecodeAcceleratorTestEnvironment(jpeg_filenames)));
 
   return RUN_ALL_TESTS();
 }