AVFoundation NSString*, cache them in the AVFoundationInternal LazyInstance.

media/video/capture/mac/avfoundation_glue.mm

 // Copyright 2013 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.
 
 #import "media/video/capture/mac/avfoundation_glue.h"
 
 #include <dlfcn.h>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 10 matching lines @@
 class AVFoundationInternal {
  public:
   AVFoundationInternal() {
     bundle_ = [NSBundle
         bundleWithPath:@"/System/Library/Frameworks/AVFoundation.framework"];
 
     const char* path = [[bundle_ executablePath] fileSystemRepresentation];
     CHECK(path);
     library_handle_ = dlopen(path, RTLD_LAZY | RTLD_LOCAL);
     CHECK(library_handle_) << dlerror();
+
+    AVCaptureDeviceWasConnectedNotification_ = *reinterpret_cast<NSString**>(

[tommi (sloooow) - chröme, 2014/01/14 15:08:49]

There's lot of code duplication here.  What about something like this:

struct {
  NSString** loaded_string;
  const char* symbol;
} av_strings[] = {
  {&AVCaptureDeviceWasConnectedNotification_,
"AVCaptureDeviceWasConnectedNotification"},
  {&AVCaptureDeviceWasDisconnectedNotification_,
"AVCaptureDeviceWasDisconnectedNotification"},
  ... etc ...
};

for (size_t i = 0; i < arraysize(av_strings); ++i) {
  *av_strings[i].loaded_string = *reinterpret_cast<NSString**>(
      dlsym(library_handle_, av_strings[i].symbol));
  DCHECK(*av_strings[i].loaded_string) << dlerror();
}

+        dlsym(library_handle_, "AVCaptureDeviceWasConnectedNotification"));
+    DCHECK(AVCaptureDeviceWasConnectedNotification_) << dlerror();
+    AVCaptureDeviceWasDisconnectedNotification_ = *reinterpret_cast<NSString**>(
+        dlsym(library_handle_, "AVCaptureDeviceWasDisconnectedNotification"));
+    DCHECK(AVCaptureDeviceWasDisconnectedNotification_) << dlerror();
+
+    AVMediaTypeVideo_ = *reinterpret_cast<NSString**>(
+        dlsym(library_handle_, "AVMediaTypeVideo"));
+    DCHECK(AVMediaTypeVideo_) << dlerror();
+    AVMediaTypeAudio_ = *reinterpret_cast<NSString**>(
+        dlsym(library_handle_, "AVMediaTypeAudio"));
+    DCHECK(AVMediaTypeAudio_) << dlerror();
+    AVMediaTypeMuxed_ = *reinterpret_cast<NSString**>(
+        dlsym(library_handle_, "AVMediaTypeMuxed"));
+    DCHECK(AVMediaTypeMuxed_) << dlerror();
+
+    AVCaptureSessionRuntimeErrorNotification_ = *reinterpret_cast<NSString**>(
+        dlsym(library_handle_, "AVCaptureSessionRuntimeErrorNotification"));
+    DCHECK(AVCaptureSessionRuntimeErrorNotification_) << dlerror();
+    AVCaptureSessionDidStopRunningNotification_ = *reinterpret_cast<NSString**>(
+        dlsym(library_handle_, "AVCaptureSessionDidStopRunningNotification"));
+    DCHECK(AVCaptureSessionDidStopRunningNotification_) << dlerror();
+    AVCaptureSessionErrorKey_ = *reinterpret_cast<NSString**>(
+        dlsym(library_handle_, "AVCaptureSessionErrorKey"));
+    DCHECK(AVCaptureSessionErrorKey_) << dlerror();
+
+    AVCaptureSessionPreset320x240_ = *reinterpret_cast<NSString**>(
+        dlsym(library_handle_, "AVCaptureSessionPreset320x240"));
+    DCHECK(AVCaptureSessionPreset320x240_) << dlerror();
+    AVCaptureSessionPreset640x480_ = *reinterpret_cast<NSString**>(
+        dlsym(library_handle_, "AVCaptureSessionPreset640x480"));
+    DCHECK(AVCaptureSessionPreset640x480_) << dlerror();
+    AVCaptureSessionPreset1280x720_ = *reinterpret_cast<NSString**>(
+        dlsym(library_handle_, "AVCaptureSessionPreset1280x720"));
+    DCHECK(AVCaptureSessionPreset1280x720_) << dlerror();
+
+    AVVideoScalingModeKey_ = *reinterpret_cast<NSString**>(
+        dlsym(library_handle_, "AVVideoScalingModeKey"));
+    DCHECK(AVVideoScalingModeKey_) << dlerror();
+    AVVideoScalingModeResizeAspect_ = *reinterpret_cast<NSString**>(
+        dlsym(library_handle_, "AVVideoScalingModeResizeAspect"));
+    DCHECK(AVVideoScalingModeResizeAspect_) << dlerror();
   }
+
   NSBundle* bundle() const { return bundle_; }
   void* library_handle() const { return library_handle_; }
 
+  NSString* AVCaptureDeviceWasConnectedNotification() const {
+    return AVCaptureDeviceWasConnectedNotification_;
+  }
+  NSString* AVCaptureDeviceWasDisconnectedNotification() const {
+    return AVCaptureDeviceWasDisconnectedNotification_;
+  }
+  NSString* AVMediaTypeVideo() const { return AVMediaTypeVideo_; }
+  NSString* AVMediaTypeAudio() const { return AVMediaTypeAudio_; }
+  NSString* AVMediaTypeMuxed() const { return AVMediaTypeMuxed_; }
+  NSString* AVCaptureSessionRuntimeErrorNotification() const {
+    return AVCaptureSessionRuntimeErrorNotification_;
+  }
+  NSString* AVCaptureSessionDidStopRunningNotification() const {
+    return AVCaptureSessionDidStopRunningNotification_;
+  }
+  NSString* AVCaptureSessionErrorKey() const {
+    return AVCaptureSessionErrorKey_;
+  }
+  NSString* AVCaptureSessionPreset320x240() const {
+    return AVCaptureSessionPreset320x240_;
+  }
+  NSString* AVCaptureSessionPreset640x480() const {
+    return AVCaptureSessionPreset640x480_;
+  }
+  NSString* AVCaptureSessionPreset1280x720() const {
+    return AVCaptureSessionPreset1280x720_;
+  }
+  NSString* AVVideoScalingModeKey() const { return AVVideoScalingModeKey_; }
+  NSString* AVVideoScalingModeResizeAspect() const {
+    return AVVideoScalingModeResizeAspect_;
+  }
+
  private:
   NSBundle* bundle_;
   void* library_handle_;
+  NSString* AVCaptureDeviceWasConnectedNotification_;

[tommi (sloooow) - chröme, 2014/01/14 15:08:49]

Since these names don't adhere to the style guide, you could add a comment here
explaining why.

+  NSString* AVCaptureDeviceWasDisconnectedNotification_;
+  NSString* AVMediaTypeVideo_;
+  NSString* AVMediaTypeAudio_;
+  NSString* AVMediaTypeMuxed_;
+  NSString* AVCaptureSessionRuntimeErrorNotification_;
+  NSString* AVCaptureSessionDidStopRunningNotification_;
+  NSString* AVCaptureSessionErrorKey_;
+  NSString* AVCaptureSessionPreset320x240_;
+  NSString* AVCaptureSessionPreset640x480_;
+  NSString* AVCaptureSessionPreset1280x720_;
+  NSString* AVVideoScalingModeKey_;
+  NSString* AVVideoScalingModeResizeAspect_;
 
   DISALLOW_COPY_AND_ASSIGN(AVFoundationInternal);
 };
 
 }  // namespace
 
 static base::LazyInstance<AVFoundationInternal> g_avfoundation_handle =
     LAZY_INSTANCE_INITIALIZER;
 
-namespace media {
-
-// TODO(mcasas):http://crbug.com/323536 cache the string pointers.
-static NSString* ReadNSStringPtr(const char* symbol) {
-  NSString** string_pointer = reinterpret_cast<NSString**>(
-      dlsym(AVFoundationGlue::AVFoundationLibraryHandle(), symbol));
-  DCHECK(string_pointer) << dlerror();
-  return *string_pointer;
-}
-
-}  // namespace media
-
 bool AVFoundationGlue::IsAVFoundationSupported() {
   if (!base::mac::IsOSLionOrLater())
     return false;
   const std::string group_name =
       base::FieldTrialList::FindFullName("AVFoundationMacVideoCapture");
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
   return (cmd_line->HasSwitch(switches::kEnableAVFoundation) ||
       group_name == "Enabled") && [AVFoundationBundle() load];
 }
 
 NSBundle const* AVFoundationGlue::AVFoundationBundle() {
   return g_avfoundation_handle.Get().bundle();
 }
 
 void* AVFoundationGlue::AVFoundationLibraryHandle() {
   return g_avfoundation_handle.Get().library_handle();
 }
 
 NSString* AVFoundationGlue::AVCaptureDeviceWasConnectedNotification() {
-  return media::ReadNSStringPtr("AVCaptureDeviceWasConnectedNotification");
+  return g_avfoundation_handle.Get().AVCaptureDeviceWasConnectedNotification();
 }
 
 NSString* AVFoundationGlue::AVCaptureDeviceWasDisconnectedNotification() {
-  return media::ReadNSStringPtr("AVCaptureDeviceWasDisconnectedNotification");
+  return
+      g_avfoundation_handle.Get().AVCaptureDeviceWasDisconnectedNotification();
 }
 
 NSString* AVFoundationGlue::AVMediaTypeVideo() {
-  return media::ReadNSStringPtr("AVMediaTypeVideo");
+  return g_avfoundation_handle.Get().AVMediaTypeVideo();
 }
 
 NSString* AVFoundationGlue::AVMediaTypeAudio() {
-  return media::ReadNSStringPtr("AVMediaTypeAudio");
+  return g_avfoundation_handle.Get().AVMediaTypeAudio();
 }
 
 NSString* AVFoundationGlue::AVMediaTypeMuxed() {
-  return media::ReadNSStringPtr("AVMediaTypeMuxed");
+  return g_avfoundation_handle.Get().AVMediaTypeMuxed();
 }
 
 NSString* AVFoundationGlue::AVCaptureSessionRuntimeErrorNotification() {
-  return media::ReadNSStringPtr("AVCaptureSessionRuntimeErrorNotification");
+  return g_avfoundation_handle.Get().AVCaptureSessionRuntimeErrorNotification();
 }
 
 NSString* AVFoundationGlue::AVCaptureSessionDidStopRunningNotification() {
-  return media::ReadNSStringPtr("AVCaptureSessionDidStopRunningNotification");
+  return
+      g_avfoundation_handle.Get().AVCaptureSessionDidStopRunningNotification();
 }
 
 NSString* AVFoundationGlue::AVCaptureSessionErrorKey() {
-  return media::ReadNSStringPtr("AVCaptureSessionErrorKey");
+  return g_avfoundation_handle.Get().AVCaptureSessionErrorKey();
 }
 
 NSString* AVFoundationGlue::AVCaptureSessionPreset320x240() {
-  return media::ReadNSStringPtr("AVCaptureSessionPreset320x240");
+  return g_avfoundation_handle.Get().AVCaptureSessionPreset320x240();
 }
 
 NSString* AVFoundationGlue::AVCaptureSessionPreset640x480() {
-  return media::ReadNSStringPtr("AVCaptureSessionPreset640x480");
+  return g_avfoundation_handle.Get().AVCaptureSessionPreset640x480();
 }
 
 NSString* AVFoundationGlue::AVCaptureSessionPreset1280x720() {
-  return media::ReadNSStringPtr("AVCaptureSessionPreset1280x720");
+  return g_avfoundation_handle.Get().AVCaptureSessionPreset1280x720();
 }
 
 NSString* AVFoundationGlue::AVVideoScalingModeKey() {
-  return media::ReadNSStringPtr("AVVideoScalingModeKey");
+  return g_avfoundation_handle.Get().AVVideoScalingModeKey();
 }
 
 NSString* AVFoundationGlue::AVVideoScalingModeResizeAspect() {
-  return media::ReadNSStringPtr("AVVideoScalingModeResizeAspect");
+  return g_avfoundation_handle.Get().AVVideoScalingModeResizeAspect();
 }
 
 Class AVFoundationGlue::AVCaptureSessionClass() {
   return [AVFoundationBundle() classNamed:@"AVCaptureSession"];
 }
 
 Class AVFoundationGlue::AVCaptureVideoDataOutputClass() {
   return [AVFoundationBundle() classNamed:@"AVCaptureVideoDataOutput"];
 }
 
@@ skipping 20 matching lines @@
 @implementation AVCaptureDeviceInputGlue
 
 + (CrAVCaptureDeviceInput*)deviceInputWithDevice:(CrAVCaptureDevice*)device
                                            error:(NSError**)outError {
   return [[AVFoundationGlue::AVFoundationBundle()
       classNamed:@"AVCaptureDeviceInput"] deviceInputWithDevice:device
                                                           error:outError];
 }
 
 @end  // @implementation AVCaptureDeviceInputGlue