Explicitly check for --no-sandbox in VT VDA.

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 <CoreVideo/CoreVideo.h>
 #include <OpenGL/CGLIOSurface.h>
 
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/common/gpu/media/vt_video_decode_accelerator.h"
+#include "content/public/common/content_switches.h"
 #include "media/filters/h264_parser.h"
 
 using content_common_gpu_media::kModuleVt;
 using content_common_gpu_media::InitializeStubs;
 using content_common_gpu_media::IsVtInitialized;
 using content_common_gpu_media::StubPathMap;
 
 namespace content {
 
 // Size of length headers prepended to NALUs in MPEG-4 framing. (1, 2, or 4.)
@@ skipping 34 matching lines @@
 bool VTVideoDecodeAccelerator::Initialize(
     media::VideoCodecProfile profile,
     Client* client) {
   DCHECK(CalledOnValidThread());
   client_ = client;
 
   // Only H.264 is supported.
   if (profile < media::H264PROFILE_MIN || profile > media::H264PROFILE_MAX)
     return false;
 
-  // TODO(sandersd): Move VideoToolbox library loading to sandbox startup;
-  // until then, --no-sandbox is required.
+  // Require --no-sandbox until VideoToolbox library loading is part of sandbox
+  // startup (and this VDA is ready for regular users).
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kNoSandbox))
+    return false;
+
   if (!IsVtInitialized()) {
     StubPathMap paths;
     // 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 for VideoToolbox.
     paths[kModuleVt].push_back(FILE_PATH_LITERAL(
         "/System/Library/Frameworks/VideoToolbox.framework/VideoToolbox"));
     if (!InitializeStubs(paths))
       return false;
   }
 
   // Spawn a thread to handle parsing and calling VideoToolbox.
   if (!decoder_thread_.Start())
     return false;
 
-  // Note that --ignore-gpu-blacklist is still required to get here.
   return true;
 }
 
 // TODO(sandersd): Proper error reporting instead of CHECKs.
 void VTVideoDecodeAccelerator::ConfigureDecoder(
     const std::vector<const uint8_t*>& nalu_data_ptrs,
     const std::vector<size_t>& nalu_data_sizes) {
   format_.reset();
   CHECK(!CMVideoFormatDescriptionCreateFromH264ParameterSets(
       kCFAllocatorDefault,
@@ skipping 38 matching lines @@
   CFDictionarySetValue(
       image_config, kCVPixelBufferPixelFormatTypeKey, cf_pixel_format);
   CFDictionarySetValue(image_config, kCVPixelBufferWidthKey, cf_width);
   CFDictionarySetValue(image_config, kCVPixelBufferHeightKey, cf_height);
   CFDictionarySetValue(
       image_config, kCVPixelBufferOpenGLCompatibilityKey, kCFBooleanTrue);
 
   // TODO(sandersd): Skip if the session is compatible.
   // TODO(sandersd): Flush frames when resetting.
   session_.reset();
   CHECK(!VTDecompressionSessionCreate(

[scherkus (not reviewing), 2014/07/23 20:30:54]

FYI the crash reports are hitting this CHECK()

I would think that we'd fail earlier in IsVtInitialized() if the sandbox was in
the way

OOC have you been able to reproduce the crash?

[sandersd (OOO until July 31), 2014/07/23 20:36:47]

I can confirm that initialization can succeed inside the sandbox, the result is
that it uses its internal software decoder.

That said, I didn't attempt to reproduce this crash. It could happen if there
are additional SPS/PPS units in the first few frames, or it could be that this
method fails more often than we expect.

       kCFAllocatorDefault,
       format_,              // video_format_description
       decoder_config,       // video_decoder_specification
       image_config,         // destination_image_buffer_attributes
       &callback_,           // output_callback
       session_.InitializeInto()
   ));
   DVLOG(2) << "Created VTDecompressionSession";
 }
 
@@ skipping 76 matching lines @@
   DCHECK(CalledOnValidThread());
   // TODO(sandersd): Trigger flush, discarding frames, and wait for them.
   delete this;
 }
 
 bool VTVideoDecodeAccelerator::CanDecodeOnIOThread() {
   return false;
 }
 
 }  // namespace content