windows: improve code

Signed-off-by: Jonathan Schwender <jonathan.schwender@huawei.com>

Author: jschwe

src/platform/generic/egl/device.rs

@@ -25,7 +25,7 @@ thread_local! {
 lazy_static! {
     static ref EGL_LIBRARY: EGLLibraryWrapper = {
         unsafe {
-            let module = libloaderapi::LoadLibraryA(&c"libEGL.dll"[0] as *const u8 as LPCSTR);
+            let module = libloaderapi::LoadLibraryA(c"libEGL.dll".as_ptr());
             EGLLibraryWrapper(module)
         }
     };

src/platform/windows/wgl/context.rs

@@ -148,7 +148,7 @@ pub struct NativeContext(pub HGLRC);
 thread_local! {
     static OPENGL_LIBRARY: HMODULE = {
         unsafe {
-            libloaderapi::LoadLibraryA(&c"opengl32.dll"[0] as *const u8 as LPCSTR)
+            libloaderapi::LoadLibraryA(c"opengl32.dll".as_ptr())
         }
     };
 }
@@ -640,7 +640,7 @@ impl NativeContext {
 fn extension_loader_thread() -> WGLExtensionFunctions {
     unsafe {
         let instance = libloaderapi::GetModuleHandleA(ptr::null_mut());
-        let window_class_name = &c"SurfmanFalseWindow"[0] as *const u8 as LPCSTR;
+        let window_class_name = &c"SurfmanFalseWindow".as_ptr();
         let window_class = WNDCLASSA {
             style: CS_OWNDC,
             lpfnWndProc: Some(extension_loader_window_proc),
@@ -733,7 +733,7 @@ extern "system" fn extension_loader_window_proc(
                 let wgl_extension_functions =
                     (*create_struct).lpCreateParams as *mut WGLExtensionFunctions;
                 (*wgl_extension_functions).GetExtensionsStringARB = mem::transmute(
-                    wglGetProcAddress(&c"wglGetExtensionsStringARB"[0] as *const u8 as LPCSTR),
+                    wglGetProcAddress(&c"wglGetExtensionsStringARB".as_ptr()),
                 );
                 let extensions = match (*wgl_extension_functions).GetExtensionsStringARB {
                     Some(wglGetExtensionsStringARB) => {
@@ -748,44 +748,44 @@ extern "system" fn extension_loader_window_proc(
                         (*wgl_extension_functions).pixel_format_functions =
                             Some(WGLPixelFormatExtensionFunctions {
                                 ChoosePixelFormatARB: mem::transmute(wglGetProcAddress(
-                                    &c"wglChoosePixelFormatARB"[0] as *const u8 as LPCSTR,
+                                    &c"wglChoosePixelFormatARB".as_ptr(),
                                 )),
                                 GetPixelFormatAttribivARB: mem::transmute(wglGetProcAddress(
-                                    &c"wglGetPixelFormatAttribivARB"[0] as *const u8 as LPCSTR,
+                                    &c"wglGetPixelFormatAttribivARB".as_ptr(),
                                 )),
                             });
                         continue;
                     }
                     if extension == "WGL_ARB_create_context" {
                         (*wgl_extension_functions).CreateContextAttribsARB =
                             mem::transmute(wglGetProcAddress(
-                                &c"wglCreateContextAttribsARB"[0] as *const u8 as LPCSTR,
+                                &c"wglCreateContextAttribsARB".as_ptr(),
                             ));
                         continue;
                     }
                     if extension == "WGL_NV_DX_interop" {
                         (*wgl_extension_functions).dx_interop_functions =
                             Some(WGLDXInteropExtensionFunctions {
                                 DXCloseDeviceNV: mem::transmute(wglGetProcAddress(
-                                    &c"wglDXCloseDeviceNV"[0] as *const u8 as LPCSTR,
+                                    &c"wglDXCloseDeviceNV".as_ptr(),
                                 )),
                                 DXLockObjectsNV: mem::transmute(wglGetProcAddress(
-                                    &c"wglDXLockObjectsNV"[0] as *const u8 as LPCSTR,
+                                    &c"wglDXLockObjectsNV".as_ptr(),
                                 )),
                                 DXOpenDeviceNV: mem::transmute(wglGetProcAddress(
-                                    &c"wglDXOpenDeviceNV"[0] as *const u8 as LPCSTR,
+                                    &c"wglDXOpenDeviceNV".as_ptr(),
                                 )),
                                 DXRegisterObjectNV: mem::transmute(wglGetProcAddress(
-                                    &c"wglDXRegisterObjectNV"[0] as *const u8 as LPCSTR,
+                                    &c"wglDXRegisterObjectNV".as_ptr(),
                                 )),
                                 DXSetResourceShareHandleNV: mem::transmute(wglGetProcAddress(
-                                    &c"wglDXSetResourceShareHandleNV"[0] as *const u8 as LPCSTR,
+                                    &c"wglDXSetResourceShareHandleNV".as_ptr(),
                                 )),
                                 DXUnlockObjectsNV: mem::transmute(wglGetProcAddress(
-                                    &c"wglDXUnlockObjectsNV"[0] as *const u8 as LPCSTR,
+                                    &c"wglDXUnlockObjectsNV".as_ptr(),
                                 )),
                                 DXUnregisterObjectNV: mem::transmute(wglGetProcAddress(
-                                    &c"wglDXUnregisterObjectNV"[0] as *const u8 as LPCSTR,
+                                    &c"wglDXUnregisterObjectNV".as_ptr(),
                                 )),
                             });
                         continue;

src/platform/windows/wgl/device.rs

@@ -28,8 +28,8 @@ pub(crate) const HIDDEN_WINDOW_SIZE: c_int = 16;
 
 const INTEL_PCI_ID: UINT = 0x8086;
 
-static NVIDIA_GPU_SELECT_SYMBOL: &[u8] = c"NvOptimusEnablement";
-static AMD_GPU_SELECT_SYMBOL: &[u8] = c"AmdPowerXpressRequestHighPerformance";
+static NVIDIA_GPU_SELECT_SYMBOL: &CStr = c"NvOptimusEnablement";
+static AMD_GPU_SELECT_SYMBOL: &CStr = c"AmdPowerXpressRequestHighPerformance";
 
 /// Represents a hardware display adapter that can be used for rendering (including the CPU).
 ///
@@ -78,11 +78,11 @@ impl Adapter {
             assert!(!current_module.is_null());
             let nvidia_gpu_select_variable: *mut i32 = libloaderapi::GetProcAddress(
                 current_module,
-                NVIDIA_GPU_SELECT_SYMBOL.as_ptr() as LPCSTR,
+                NVIDIA_GPU_SELECT_SYMBOL.as_ptr(),
             ) as *mut i32;
             let amd_gpu_select_variable: *mut i32 = libloaderapi::GetProcAddress(
                 current_module,
-                AMD_GPU_SELECT_SYMBOL.as_ptr() as LPCSTR,
+                AMD_GPU_SELECT_SYMBOL.as_ptr(),
             ) as *mut i32;
             if nvidia_gpu_select_variable.is_null() || amd_gpu_select_variable.is_null() {
                 println!(
@@ -308,7 +308,7 @@ impl HiddenWindow {
     fn thread(sender: Sender<SendableHWND>) {
         unsafe {
             let instance = libloaderapi::GetModuleHandleA(ptr::null_mut());
-            let window_class_name = &c"SurfmanHiddenWindow"[0] as *const u8 as LPCSTR;
+            let window_class_name = c"SurfmanHiddenWindow".as_ptr();
             let mut window_class = mem::zeroed();
             if winuser::GetClassInfoA(instance, window_class_name, &mut window_class) == FALSE {
                 window_class = WNDCLASSA {