Test X11 header pollution

media/gpu/vt_video_encode_accelerator_mac.cc

 // Copyright 2016 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/vt_video_encode_accelerator_mac.h"
+#include "media/gpu/vt_video_encode_accelerator_mac.h"
 
 #include <memory>
 
 #include "base/thread_task_runner_handle.h"
 #include "media/base/mac/coremedia_glue.h"
 #include "media/base/mac/corevideo_glue.h"
 #include "media/base/mac/video_frame_mac.h"
 
-namespace content {
+namespace media {
 
 namespace {
 
 // TODO(emircan): Check if we can find the actual system capabilities via
 // creating VTCompressionSessions with varying requirements.
 // See crbug.com/584784.
 const size_t kBitsPerByte = 8;
 const size_t kDefaultResolutionWidth = 640;
 const size_t kDefaultResolutionHeight = 480;
 const size_t kMaxFrameRateNumerator = 30;
 const size_t kMaxFrameRateDenominator = 1;
 const size_t kMaxResolutionWidth = 4096;
 const size_t kMaxResolutionHeight = 2160;
 const size_t kNumInputBuffers = 3;
 
 }  // namespace
 
 struct VTVideoEncodeAccelerator::InProgressFrameEncode {
-  InProgressFrameEncode(base::TimeDelta rtp_timestamp,
-                        base::TimeTicks ref_time)
+  InProgressFrameEncode(base::TimeDelta rtp_timestamp, base::TimeTicks ref_time)
       : timestamp(rtp_timestamp), reference_time(ref_time) {}
   const base::TimeDelta timestamp;
   const base::TimeTicks reference_time;
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(InProgressFrameEncode);
 };
 
 struct VTVideoEncodeAccelerator::EncodeOutput {
   EncodeOutput(VTEncodeInfoFlags info_flags, CMSampleBufferRef sbuf)
@@ skipping 78 matching lines @@
            << ", initial_bitrate=" << initial_bitrate;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(client);
 
   if (media::PIXEL_FORMAT_I420 != format) {
     DLOG(ERROR) << "Input format not supported= "
                 << media::VideoPixelFormatToString(format);
     return false;
   }
   if (media::H264PROFILE_BASELINE != output_profile) {
-    DLOG(ERROR) << "Output profile not supported= "
-                << output_profile;
+    DLOG(ERROR) << "Output profile not supported= " << output_profile;
     return false;
   }
 
   videotoolbox_glue_ = VideoToolboxGlue::Get();
   if (!videotoolbox_glue_) {
     DLOG(ERROR) << "Failed creating VideoToolbox glue.";
     return false;
   }
 
   client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client));
@@ skipping 76 matching lines @@
 
 void VTVideoEncodeAccelerator::Destroy() {
   DVLOG(3) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Cancel all callbacks.
   client_ptr_factory_.reset();
 
   if (encoder_thread_.IsRunning()) {
     encoder_thread_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&VTVideoEncodeAccelerator::DestroyTask,
-                   base::Unretained(this)));
+        FROM_HERE, base::Bind(&VTVideoEncodeAccelerator::DestroyTask,
+                              base::Unretained(this)));
     encoder_thread_.Stop();
   } else {
     DestroyTask();
   }
 }
 
 void VTVideoEncodeAccelerator::EncodeTask(
     const scoped_refptr<media::VideoFrame>& frame,
     bool force_keyframe) {
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
@@ skipping 165 matching lines @@
     client_task_runner_->PostTask(
         FROM_HERE, base::Bind(&Client::BitstreamBufferReady, client_,
                               buffer_ref->id, 0, false));
     return;
   }
 
   auto sample_attachments = static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(
       CoreMediaGlue::CMSampleBufferGetSampleAttachmentsArray(
           encode_output->sample_buffer.get(), true),
       0));
-  const bool keyframe =
-      !CFDictionaryContainsKey(sample_attachments,
-                               CoreMediaGlue::kCMSampleAttachmentKey_NotSync());
+  const bool keyframe = !CFDictionaryContainsKey(
+      sample_attachments, CoreMediaGlue::kCMSampleAttachmentKey_NotSync());
 
   size_t used_buffer_size = 0;
   const bool copy_rv = media::video_toolbox::CopySampleBufferToAnnexBBuffer(
       encode_output->sample_buffer.get(), keyframe, buffer_ref->size,
       reinterpret_cast<char*>(buffer_ref->shm->memory()), &used_buffer_size);
   if (!copy_rv) {
     DLOG(ERROR) << "Cannot copy output from SampleBuffer to AnnexBBuffer.";
     used_buffer_size = 0;
   }
 
   client_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Client::BitstreamBufferReady, client_,
                             buffer_ref->id, used_buffer_size, keyframe));
 }
 
 bool VTVideoEncodeAccelerator::ResetCompressionSession() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DestroyCompressionSession();
 
-  CFTypeRef attributes_keys[] = {
-    kCVPixelBufferOpenGLCompatibilityKey,
-    kCVPixelBufferIOSurfacePropertiesKey,
-    kCVPixelBufferPixelFormatTypeKey
-  };
+  CFTypeRef attributes_keys[] = {kCVPixelBufferOpenGLCompatibilityKey,
+                                 kCVPixelBufferIOSurfacePropertiesKey,
+                                 kCVPixelBufferPixelFormatTypeKey};
   const int format[] = {
       CoreVideoGlue::kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange};
   CFTypeRef attributes_values[] = {
       kCFBooleanTrue,
       media::video_toolbox::DictionaryWithKeysAndValues(nullptr, nullptr, 0)
           .release(),
       media::video_toolbox::ArrayWithIntegers(format, arraysize(format))
           .release()};
   const base::ScopedCFTypeRef<CFDictionaryRef> attributes =
       media::video_toolbox::DictionaryWithKeysAndValues(
@@ skipping 16 matching lines @@
 
 bool VTVideoEncodeAccelerator::CreateCompressionSession(
     base::ScopedCFTypeRef<CFDictionaryRef> attributes,
     const gfx::Size& input_size,
     bool require_hw_encoding) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::vector<CFTypeRef> encoder_keys;
   std::vector<CFTypeRef> encoder_values;
   if (require_hw_encoding) {
-    encoder_keys.push_back(videotoolbox_glue_
-      ->kVTVideoEncoderSpecification_RequireHardwareAcceleratedVideoEncoder());
+    encoder_keys.push_back(
+        videotoolbox_glue_
+            ->kVTVideoEncoderSpecification_RequireHardwareAcceleratedVideoEncoder());
     encoder_values.push_back(kCFBooleanTrue);
   } else {
-    encoder_keys.push_back(videotoolbox_glue_
-        ->kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder());
+    encoder_keys.push_back(
+        videotoolbox_glue_
+            ->kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder());
     encoder_values.push_back(kCFBooleanTrue);
   }
   base::ScopedCFTypeRef<CFDictionaryRef> encoder_spec =
       media::video_toolbox::DictionaryWithKeysAndValues(
           encoder_keys.data(), encoder_values.data(), encoder_keys.size());
 
   // Create the compression session.
   // Note that the encoder object is given to the compression session as the
   // callback context using a raw pointer. The C API does not allow us to use a
   // smart pointer, nor is this encoder ref counted. However, this is still
   // safe, because we 1) we own the compression session and 2) we tear it down
   // safely. When destructing the encoder, the compression session is flushed
   // and invalidated. Internally, VideoToolbox will join all of its threads
   // before returning to the client. Therefore, when control returns to us, we
   // are guaranteed that the output callback will not execute again.
   OSStatus status = videotoolbox_glue_->VTCompressionSessionCreate(
-      kCFAllocatorDefault,
-      input_size.width(),
-      input_size.height(),
-      CoreMediaGlue::kCMVideoCodecType_H264,
-      encoder_spec,
-      attributes,
+      kCFAllocatorDefault, input_size.width(), input_size.height(),
+      CoreMediaGlue::kCMVideoCodecType_H264, encoder_spec, attributes,
       nullptr /* compressedDataAllocator */,
       &VTVideoEncodeAccelerator::CompressionCallback,
-      reinterpret_cast<void*>(this),
-      compression_session_.InitializeInto());
+      reinterpret_cast<void*>(this), compression_session_.InitializeInto());
   if (status != noErr) {
     DLOG(ERROR) << " VTCompressionSessionCreate failed: " << status;
     return false;
   }
   DVLOG(3) << " VTCompressionSession created with HW encode: "
            << require_hw_encoding << ", input size=" << input_size.ToString();
   return true;
 }
 
 bool VTVideoEncodeAccelerator::ConfigureCompressionSession() {
@@ skipping 19 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread() ||
          (encoder_thread_.IsRunning() &&
           encoder_thread_task_runner_->BelongsToCurrentThread()));
 
   if (compression_session_) {
     videotoolbox_glue_->VTCompressionSessionInvalidate(compression_session_);
     compression_session_.reset();
   }
 }
 
-} // namespace content
+}  // namespace media