Only dlopen() OMX/VAAPI libs in the GPU process, and only lazily dlsym() their symbols.

content/common/gpu/media/omx_video_decode_accelerator.cc

 // Copyright (c) 2012 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/omx_video_decode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/media/gles2_texture_to_egl_image_translator.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/video/picture.h"
 
 // Helper typedef for input buffers.  This is used as the pAppPrivate field of
 // OMX_BUFFERHEADERTYPEs of input buffers, to point to the data associated with
 // them.
 typedef std::pair<scoped_ptr<base::SharedMemory>, int32> SharedMemoryAndId;
 
 enum { kNumPictureBuffers = 4 };
 
-// Open the libOmxCore here for now.
-void* omx_handle = dlopen("libOmxCore.so", RTLD_NOW);
+void* omx_handle = NULL;
 
 typedef OMX_ERRORTYPE (*OMXInit)();
 typedef OMX_ERRORTYPE (*OMXGetHandle)(
     OMX_HANDLETYPE*, OMX_STRING, OMX_PTR, OMX_CALLBACKTYPE*);
 typedef OMX_ERRORTYPE (*OMXGetComponentsOfRole)(OMX_STRING, OMX_U32*, OMX_U8**);
 typedef OMX_ERRORTYPE (*OMXFreeHandle)(OMX_HANDLETYPE);
 typedef OMX_ERRORTYPE (*OMXDeinit)();
 
-OMXInit omx_init = reinterpret_cast<OMXInit>(dlsym(omx_handle, "OMX_Init"));
-OMXGetHandle omx_gethandle =
-    reinterpret_cast<OMXGetHandle>(dlsym(omx_handle, "OMX_GetHandle"));
-OMXGetComponentsOfRole omx_get_components_of_role =
-    reinterpret_cast<OMXGetComponentsOfRole>(
-        dlsym(omx_handle, "OMX_GetComponentsOfRole"));
-OMXFreeHandle omx_free_handle =
-    reinterpret_cast<OMXFreeHandle>(dlsym(omx_handle, "OMX_FreeHandle"));
-OMXDeinit omx_deinit =
-    reinterpret_cast<OMXDeinit>(dlsym(omx_handle, "OMX_Deinit"));
-
-static bool AreOMXFunctionPointersInitialized() {
-  return (omx_init && omx_gethandle && omx_get_components_of_role &&
-          omx_free_handle && omx_deinit);
-}
+OMXInit omx_init = NULL;
+OMXGetHandle omx_gethandle = NULL;
+OMXGetComponentsOfRole omx_get_components_of_role = NULL;
+OMXFreeHandle omx_free_handle = NULL;
+OMXDeinit omx_deinit = NULL;
 
 // Maps h264-related Profile enum values to OMX_VIDEO_AVCPROFILETYPE values.
 static OMX_U32 MapH264ProfileToOMXAVCProfile(uint32 profile) {
   switch (profile) {
     case media::H264PROFILE_BASELINE:
       return OMX_VIDEO_AVCProfileBaseline;
     case media::H264PROFILE_MAIN:
       return OMX_VIDEO_AVCProfileMain;
     case media::H264PROFILE_EXTENDED:
       return OMX_VIDEO_AVCProfileExtended;
@@ skipping 31 matching lines @@
     }                                                              \
   } while (0)
 
 // OMX-specific version of RETURN_ON_FAILURE which compares with OMX_ErrorNone.
 #define RETURN_ON_OMX_FAILURE(omx_result, log, error, ret_val)          \
   RETURN_ON_FAILURE(                                                    \
       ((omx_result) == OMX_ErrorNone),                                  \
       log << ", OMX result: 0x" << std::hex << omx_result,              \
       error, ret_val)
 
+// static
+bool OmxVideoDecodeAccelerator::pre_sandbox_init_done_ = false;
+
 OmxVideoDecodeAccelerator::OmxVideoDecodeAccelerator(
     EGLDisplay egl_display, EGLContext egl_context,
     media::VideoDecodeAccelerator::Client* client)
     : message_loop_(MessageLoop::current()),
       component_handle_(NULL),
       weak_this_(base::AsWeakPtr(this)),
       init_begun_(false),
       client_state_(OMX_StateMax),
       current_state_change_(NO_TRANSITION),
       input_buffer_count_(0),
       input_buffer_size_(0),
       input_port_(0),
       input_buffers_at_component_(0),
       output_port_(0),
       output_buffers_at_component_(0),
       egl_display_(egl_display),
       egl_context_(egl_context),
       client_(client),
       codec_(UNKNOWN),
       h264_profile_(OMX_VIDEO_AVCProfileMax),
       component_name_is_nvidia_h264ext_(false) {
-  RETURN_ON_FAILURE(AreOMXFunctionPointersInitialized(),
+  static bool omx_functions_initialized = PostSandboxInitialization();
+  RETURN_ON_FAILURE(omx_functions_initialized,
                     "Failed to load openmax library", PLATFORM_FAILURE,);
   RETURN_ON_OMX_FAILURE(omx_init(), "Failed to init OpenMAX core",
                         PLATFORM_FAILURE,);
 }
 
 OmxVideoDecodeAccelerator::~OmxVideoDecodeAccelerator() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   DCHECK(free_input_buffers_.empty());
   DCHECK_EQ(0, input_buffers_at_component_);
   DCHECK_EQ(0, output_buffers_at_component_);
@@ skipping 855 matching lines @@
                           PLATFORM_FAILURE,);
       }
       return;
     default:
       RETURN_ON_FAILURE(false, "Unexpected unhandled event: " << event,
                         PLATFORM_FAILURE,);
   }
 }
 
 // static
+void OmxVideoDecodeAccelerator::PreSandboxInitialization() {
+  DCHECK(!pre_sandbox_init_done_);
+  omx_handle = dlopen("libOmxCore.so", RTLD_NOW);
+  pre_sandbox_init_done_ = omx_handle != NULL;
+}
+
+// static
+bool OmxVideoDecodeAccelerator::PostSandboxInitialization() {
+  if (!pre_sandbox_init_done_)
+    return false;
+
+  omx_init = reinterpret_cast<OMXInit>(dlsym(omx_handle, "OMX_Init"));
+  omx_gethandle =
+      reinterpret_cast<OMXGetHandle>(dlsym(omx_handle, "OMX_GetHandle"));
+  omx_get_components_of_role =
+      reinterpret_cast<OMXGetComponentsOfRole>(
+          dlsym(omx_handle, "OMX_GetComponentsOfRole"));
+  omx_free_handle =
+      reinterpret_cast<OMXFreeHandle>(dlsym(omx_handle, "OMX_FreeHandle"));
+  omx_deinit =
+      reinterpret_cast<OMXDeinit>(dlsym(omx_handle, "OMX_Deinit"));
+  return (omx_init && omx_gethandle && omx_get_components_of_role &&
+          omx_free_handle && omx_deinit);
+}
+
+// static
 OMX_ERRORTYPE OmxVideoDecodeAccelerator::EventHandler(OMX_HANDLETYPE component,
                                                       OMX_PTR priv_data,
                                                       OMX_EVENTTYPE event,
                                                       OMX_U32 data1,
                                                       OMX_U32 data2,
                                                       OMX_PTR event_data) {
   // Called on the OMX thread.
   OmxVideoDecodeAccelerator* decoder =
       static_cast<OmxVideoDecodeAccelerator*>(priv_data);
   DCHECK_EQ(component, decoder->component_handle_);
@@ skipping 51 matching lines @@
 
 bool OmxVideoDecodeAccelerator::SendCommandToPort(
     OMX_COMMANDTYPE cmd, int port_index) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   OMX_ERRORTYPE result = OMX_SendCommand(component_handle_,
                                          cmd, port_index, 0);
   RETURN_ON_OMX_FAILURE(result, "SendCommand() failed" << cmd,
                         PLATFORM_FAILURE, false);
   return true;
 }