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 14 matching lines @@
 using content_common_gpu_media::StubPathMap;
 
 #define NOTIFY_STATUS(name, status)          \
     do {                                     \
       OSSTATUS_DLOG(ERROR, status) << name;  \
       NotifyError(PLATFORM_FAILURE);         \
     } while (0)
 
 namespace content {
 
+// Track VideoToolbox loaded to make sure that loading is attempted once and

[DaleCurtis, 2014/12/04 01:57:31]

Seems instead you should be using a LazyInstance::Leaky to ensure startup is
only attempted once. See how this is done in media/base/media.cc --
Alternatively you can find a place which can track this without the use of
globals (note: we typically prefix these with "g_" too)

[sandersd (OOO until July 31), 2014/12/04 02:05:48]

That seems rather complicated for this use case, specifically because there is
no actual object to represent the loaded library (so a fake one would need to be
created).

The generated stub does include its own static that has this information
(accessed by IsVtInitialized() as the previous code did), but if I use that from
Initialize() then it will try to load it every time if it is failing.

I could remove g_vt_load_successful and use acombination of g_vt_load_attempted
and IsVtInitialized().

+// only once, regardless of the --no-sandbox flag.
+static bool vt_init_attempted = false;
+static bool vt_init_successful = false;
+
 // Size to use for NALU length headers in AVC format (can be 1, 2, or 4).
 static const int kNALUHeaderLength = 4;
 
 // We request 5 picture buffers from the client, each of which has a texture ID
 // that we can bind decoded frames to. We need enough to satisfy preroll, and
 // enough to avoid unnecessary stalling, but no more than that. The resource
 // requirements are low, as we don't need the textures to be backed by storage.
 static const int kNumPictureBuffers = media::limits::kMaxVideoFrames + 1;
 
 // Maximum number of frames to queue for reordering before we stop asking for
@@ skipping 34 matching lines @@
 // 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() {
+  vt_init_attempted = true;
+
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableAcceleratedVideoDecode)) {
     return;
   }
 
   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.
@@ skipping 53 matching lines @@
       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;
   }
+
+  vt_init_successful = true;
 }
 
 // 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 (!vt_init_attempted)
+    InitializeVideoToolbox();
+
+  if (!vt_init_successful)
     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 224 matching lines @@
   if (config_changed) {
     if (last_sps_.size() == 0 || last_pps_.size() == 0) {
       DLOG(ERROR) << "Invalid configuration data";
       NotifyError(INVALID_ARGUMENT);
       return;
     }
     if (!ConfigureDecoder())
       return;
   }
 
-  // If there are no non-configuration units, drop the bitstream buffer by
-  // returning an empty frame.
+  // If there are no image slices, drop the bitstream buffer by returning an
+  // empty frame.
   if (!data_size) {
     if (!FinishDelayedFrames())
       return;
     gpu_task_runner_->PostTask(FROM_HERE, base::Bind(
         &VTVideoDecodeAccelerator::DecodeDone, weak_this_, frame));
     return;
   }
 
   // If the session is not configured by this point, fail.
   if (!session_) {
@@ skipping 398 matching lines @@
   assigned_bitstream_ids_.clear();
   state_ = STATE_DESTROYING;
   QueueFlush(TASK_DESTROY);
 }
 
 bool VTVideoDecodeAccelerator::CanDecodeOnIOThread() {
   return false;
 }
 
 }  // namespace content