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

media/gpu/vaapi_jpeg_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/vaapi_jpeg_decode_accelerator.h"
+#include "media/gpu/vaapi_jpeg_decode_accelerator.h"
 
 #include <stddef.h>
 #include <string.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
-#include "content/common/gpu/media/shared_memory_region.h"
-#include "content/common/gpu/media/vaapi_picture.h"
 #include "gpu/ipc/service/gpu_channel.h"
 #include "media/base/video_frame.h"
 #include "media/filters/jpeg_parser.h"
+#include "media/gpu/shared_memory_region.h"
+#include "media/gpu/vaapi_picture.h"
 #include "third_party/libyuv/include/libyuv.h"
 
-namespace content {
+namespace media {
 
 namespace {
 // UMA errors that the VaapiJpegDecodeAccelerator class reports.
 enum VAJDADecoderFailure {
   VAAPI_ERROR = 0,
-  // UMA requires that max must be greater than 1.
-  VAJDA_DECODER_FAILURES_MAX = 2,
+  VAJDA_DECODER_FAILURES_MAX,

[Pawel Osciak, 2016/04/19 09:22:55]

Could we please keep the comment to explain why +1?

[Mark Dittmer, 2016/05/02 03:51:23]

The max is no longer greater than 1. If left, the comment would be inaccurate.

 };
 
 static void ReportToUMA(VAJDADecoderFailure failure) {
   UMA_HISTOGRAM_ENUMERATION("Media.VAJDA.DecoderFailure", failure,
-                            VAJDA_DECODER_FAILURES_MAX);
+                            VAJDA_DECODER_FAILURES_MAX + 1);
 }
 
 static unsigned int VaSurfaceFormatForJpeg(
     const media::JpegFrameHeader& frame_header) {
   // The range of sampling factor is [1, 4]. Pack them into integer to make the
   // matching code simpler. For example, 0x211 means the sampling factor are 2,
   // 1, 1 for 3 components.
   unsigned int h = 0, v = 0;
   for (int i = 0; i < frame_header.num_components; i++) {
     DCHECK_LE(frame_header.components[i].horizontal_sampling_factor, 4);
@@ skipping 31 matching lines @@
 }  // namespace
 
 VaapiJpegDecodeAccelerator::DecodeRequest::DecodeRequest(
     int32_t bitstream_buffer_id,
     std::unique_ptr<SharedMemoryRegion> shm,
     const scoped_refptr<media::VideoFrame>& video_frame)
     : bitstream_buffer_id(bitstream_buffer_id),
       shm(std::move(shm)),
       video_frame(video_frame) {}
 
-VaapiJpegDecodeAccelerator::DecodeRequest::~DecodeRequest() {
-}
+VaapiJpegDecodeAccelerator::DecodeRequest::~DecodeRequest() {}
 
 void VaapiJpegDecodeAccelerator::NotifyError(int32_t bitstream_buffer_id,
                                              Error error) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DLOG(ERROR) << "Notifying of error " << error;
   DCHECK(client_);
   client_->NotifyError(bitstream_buffer_id, error);
 }
 
 void VaapiJpegDecodeAccelerator::NotifyErrorFromDecoderThread(
@@ skipping 213 matching lines @@
 
   decoder_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VaapiJpegDecodeAccelerator::DecodeTask,
                             base::Unretained(this), base::Passed(&request)));
 }
 
 bool VaapiJpegDecodeAccelerator::IsSupported() {
   return VaapiWrapper::IsJpegDecodeSupported();
 }
 
-}  // namespace content
+}  // namespace media