Load VideoToolbox even when --no-sandbox is in use.

content/common/gpu/media/vt_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 <algorithm>
 
 #include <CoreVideo/CoreVideo.h>
 #include <OpenGL/CGLIOSurface.h>
 #include <OpenGL/gl.h>
 
@@ skipping 68 matching lines @@
 // libraries required by VideoToolbox before the GPU sandbox is enabled.
 // VideoToolbox normally loads the hardware-specific libraries lazily, so we
 // must actually create a decompression session.
 //
 // If creating a decompression session fails, hardware decoding will be disabled
 // (Initialize() will always return false). If it succeeds but a required
 // library is not loaded yet (I have not experienced this, but the details are
 // not documented), then VideoToolbox will fall back on software decoding
 // internally. If that happens, the likely solution is to expand the scope of
 // this initialization.
-void InitializeVideoToolbox() {
+static bool InitializeVideoToolboxInternal() {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kDisableAcceleratedVideoDecode)) {
-    return;
+          switches::kDisableAcceleratedVideoDecode)) {
+    return false;
   }
 
   if (!IsVtInitialized()) {
     // CoreVideo is also required, but the loader stops after the first path is
     // loaded. Instead we rely on the transitive dependency from VideoToolbox to
     // CoreVideo.
     // TODO(sandersd): Fallback to PrivateFrameworks to support OS X < 10.8.
     StubPathMap paths;
     paths[kModuleVt].push_back(FILE_PATH_LITERAL(
         "/System/Library/Frameworks/VideoToolbox.framework/VideoToolbox"));
     if (!InitializeStubs(paths))
-      return;
+      return false;
   }
 
   // Create a decoding session.
   // SPS and PPS data were taken from the 480p encoding of Big Buck Bunny.
   const uint8_t sps[] = {0x67, 0x64, 0x00, 0x1e, 0xac, 0xd9, 0x80, 0xd4, 0x3d,
                          0xa1, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
                          0x00, 0x30, 0x8f, 0x16, 0x2d, 0x9a};
   const uint8_t pps[] = {0x68, 0xe9, 0x7b, 0xcb};
   const uint8_t* data_ptrs[] = {sps, pps};
   const size_t data_sizes[] = {arraysize(sps), arraysize(pps)};
 
   base::ScopedCFTypeRef<CMFormatDescriptionRef> format;
   OSStatus status = CMVideoFormatDescriptionCreateFromH264ParameterSets(
       kCFAllocatorDefault,
       2,                          // parameter_set_count
       data_ptrs,                  // &parameter_set_pointers
       data_sizes,                 // &parameter_set_sizes
       kNALUHeaderLength,          // nal_unit_header_length
       format.InitializeInto());
   if (status) {
     OSSTATUS_LOG(ERROR, status) << "Failed to create CMVideoFormatDescription "
                                 << "while initializing VideoToolbox";
-    content_common_gpu_media::UninitializeVt();
-    return;
+    return false;
   }
 
   base::ScopedCFTypeRef<CFMutableDictionaryRef> decoder_config(
       CFDictionaryCreateMutable(
           kCFAllocatorDefault,
           1,  // capacity
           &kCFTypeDictionaryKeyCallBacks,
           &kCFTypeDictionaryValueCallBacks));
 
   CFDictionarySetValue(
@@ skipping 11 matching lines @@
   status = VTDecompressionSessionCreate(
       kCFAllocatorDefault,
       format,               // video_format_description
       decoder_config,       // video_decoder_specification
       image_config,         // destination_image_buffer_attributes
       &callback,            // output_callback
       session.InitializeInto());
   if (status) {
     OSSTATUS_LOG(ERROR, status) << "Failed to create VTDecompressionSession "
                                 << "while initializing VideoToolbox";
-    content_common_gpu_media::UninitializeVt();
-    return;
+    return false;
   }
+
+  return true;
+}
+
+bool InitializeVideoToolbox() {
+  // InitializeVideoToolbox() is called during GPU process sandbox warmup,
+  // and then only from the GPU process main thread.
+  static bool attempted = false;
+  static bool succeeded = false;
+
+  if (!attempted) {
+    attempted = true;
+    succeeded = InitializeVideoToolboxInternal();
+  }
+
+  return succeeded;
 }
 
 // Route decoded frame callbacks back into the VTVideoDecodeAccelerator.
 static void OutputThunk(
     void* decompression_output_refcon,
     void* source_frame_refcon,
     OSStatus status,
     VTDecodeInfoFlags info_flags,
     CVImageBufferRef image_buffer,
     CMTime presentation_time_stamp,
@@ skipping 50 matching lines @@
 
 VTVideoDecodeAccelerator::~VTVideoDecodeAccelerator() {
 }
 
 bool VTVideoDecodeAccelerator::Initialize(
     media::VideoCodecProfile profile,
     Client* client) {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   client_ = client;
 
-  if (!IsVtInitialized())
+  if (!InitializeVideoToolbox())
     return false;
 
   // Only H.264 is supported.
   if (profile < media::H264PROFILE_MIN || profile > media::H264PROFILE_MAX)
     return false;
 
   // Spawn a thread to handle parsing and calling VideoToolbox.
   if (!decoder_thread_.Start())
     return false;
 
@@ skipping 654 matching lines @@
   assigned_bitstream_ids_.clear();
   state_ = STATE_DESTROYING;
   QueueFlush(TASK_DESTROY);
 }
 
 bool VTVideoDecodeAccelerator::CanDecodeOnIOThread() {
   return false;
 }
 
 }  // namespace content