rename to match

mgood7123 · mgood7123 · commit 9a7aedcc3f2d · 2022-07-08T13:55:08.000+10:00
diff --git a/BUILD.gn b/BUILD.gn
@@ -3091,7 +3091,7 @@ skiasharp_build("SkiaSharp") {
     "src/xamarin/sk_compatpaint.cpp",
     "src/xamarin/sk_manageddrawable.cpp",
     "src/xamarin/sk_managedallocator.cpp",
-    "src/xamarin/sk_managed_pixel_ref.cpp",
+    "src/xamarin/sk_managedpixelref.cpp",
     "src/xamarin/sk_managedstream.cpp",
     "src/xamarin/sk_managedtracememorydump.cpp",
     "src/xamarin/sk_xamarin.cpp",
diff --git a/include/c/sk_bitmap.h b/include/c/sk_bitmap.h
@@ -41,8 +41,8 @@ SK_C_API bool sk_bitmap_try_alloc_pixels(sk_bitmap_t* cbitmap, const sk_imageinf
 SK_C_API bool sk_bitmap_try_alloc_pixels_with_flags(sk_bitmap_t* cbitmap, const sk_imageinfo_t* requestedInfo, uint32_t flags);
 SK_C_API void sk_bitmap_set_pixels(sk_bitmap_t* cbitmap, void* pixels);
 SK_C_API bool sk_bitmap_peek_pixels(sk_bitmap_t* cbitmap, sk_pixmap_t* cpixmap);
-SK_C_API void* sk_bitmap_get_pixel_ref(sk_bitmap_t* cbitmap);
-SK_C_API void sk_bitmap_set_pixel_ref(sk_bitmap_t* cbitmap, void* cpixelref, int x, int y);
+SK_C_API void* sk_bitmap_get_pixelref(sk_bitmap_t* cbitmap);
+SK_C_API void sk_bitmap_set_pixelref(sk_bitmap_t* cbitmap, void* cpixelref, int x, int y);
 SK_C_API bool sk_bitmap_extract_subset(sk_bitmap_t* cbitmap, sk_bitmap_t* dst, sk_irect_t* subset);
 SK_C_API bool sk_bitmap_extract_alpha(sk_bitmap_t* cbitmap, sk_bitmap_t* dst, const sk_paint_t* paint, sk_ipoint_t* offset);
 SK_C_API void sk_bitmap_notify_pixels_changed(sk_bitmap_t* cbitmap);
diff --git a/include/c/sk_types.h b/include/c/sk_types.h
@@ -347,7 +347,7 @@ typedef struct sk_bitmapallocator_t sk_bitmapallocator_t;
 typedef struct sk_pixmap_t sk_pixmap_t;
 typedef struct sk_colorfilter_t sk_colorfilter_t;
 // placed here to help seperate in PR
-typedef struct sk_pixel_ref_t sk_pixel_ref_t;
+typedef struct sk_pixelref_t sk_pixelref_t;
 typedef struct sk_imagefilter_t sk_imagefilter_t;
 typedef struct sk_imagefilter_croprect_t sk_imagefilter_croprect_t;
 
diff --git a/include/xamarin/sk_managed_pixel_ref.h b/include/xamarin/sk_managed_pixel_ref.h
diff --git a/include/xamarin/sk_managedpixelref.h b/include/xamarin/sk_managedpixelref.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2014 Google Inc.
+ * Copyright 2015 Xamarin Inc.
+ * Copyright 2017 Microsoft Corporation. All rights reserved.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef sk_managedpixelref_DEFINED
+#define sk_managedpixelref_DEFINED
+
+#include "sk_xamarin.h"
+
+#include "include/c/sk_types.h"
+
+SK_C_PLUS_PLUS_BEGIN_GUARD
+
+typedef void (*sk_pixelref_destroy_proc)(sk_pixelref_t* d, void* context);
+
+typedef struct {
+    sk_pixelref_destroy_proc fDestroy;
+} sk_pixelref_procs_t;
+
+SK_X_API sk_pixelref_t* sk_managedpixelref_new_from_existing(void* context, void* pixelRef);
+SK_X_API sk_pixelref_t* sk_managedpixelref_new(void* context, int32_t, int32_t, void*, size_t);
+SK_X_API void sk_managedpixelref_delete(sk_pixelref_t*);
+SK_X_API sk_isize_t sk_managedpixelref_dimensions(sk_pixelref_t*);
+SK_X_API int32_t sk_managedpixelref_width(sk_pixelref_t*);
+SK_X_API int32_t sk_managedpixelref_height(sk_pixelref_t*);
+SK_X_API size_t sk_managedpixelref_rowBytes(sk_pixelref_t*);
+SK_X_API void* sk_managedpixelref_pixels(sk_pixelref_t*);
+SK_X_API void* sk_managedpixelref_pixelref(sk_pixelref_t* d);
+SK_X_API uint32_t sk_managedpixelref_generation_id(sk_pixelref_t*);
+SK_X_API void sk_managedpixelref_notify_pixels_changed(sk_pixelref_t*);
+SK_X_API bool sk_managedpixelref_is_immutable(sk_pixelref_t*);
+SK_X_API void sk_managedpixelref_set_immutable(sk_pixelref_t*);
+//SK_X_API void sk_managedpixelref_add_generation_id_listener(sk_pixelref_t*, sk_id_change_listener_t*);
+SK_X_API void sk_managedpixelref_notify_added_to_cache(sk_pixelref_t*);
+SK_X_API void sk_managedpixelref_set_procs(sk_pixelref_procs_t procs);
+
+SK_C_PLUS_PLUS_END_GUARD
+
+#endif
diff --git a/src/c/sk_bitmap.cpp b/src/c/sk_bitmap.cpp
@@ -138,11 +138,11 @@ bool sk_bitmap_peek_pixels(sk_bitmap_t* cbitmap, sk_pixmap_t* cpixmap) {
     return AsBitmap(cbitmap)->peekPixels(AsPixmap(cpixmap));
 }
 
-SK_C_API void* sk_bitmap_get_pixel_ref(sk_bitmap_t* cbitmap) {
+SK_C_API void* sk_bitmap_get_pixelref(sk_bitmap_t* cbitmap) {
     return AsBitmap(cbitmap)->pixelRef();
 }
 
-SK_C_API void sk_bitmap_set_pixel_ref(sk_bitmap_t* cbitmap, void* cpixelref, int x, int y) {
+SK_C_API void sk_bitmap_set_pixelref(sk_bitmap_t* cbitmap, void* cpixelref, int x, int y) {
     SkPixelRef* r = (SkPixelRef*)cpixelref;
     AsBitmap(cbitmap)->setPixelRef(sk_ref_sp(r), x, y);
 }
diff --git a/src/xamarin/SkiaKeeper.c b/src/xamarin/SkiaKeeper.c
@@ -54,7 +54,7 @@
 #include "include/xamarin/sk_managedstream.h"
 // placed here to help seperate in PR
 #include "include/xamarin/sk_managedallocator.h"
-#include "include/xamarin/sk_managed_pixel_ref.h"
+#include "include/xamarin/sk_managedpixelref.h"
 #include "include/xamarin/sk_manageddrawable.h"
 #include "include/xamarin/sk_managedtracememorydump.h"
 #include "include/xamarin/sk_compatpaint.h"
@@ -112,8 +112,8 @@ void** KeepSkiaCSymbols (void)
         (void*)sk_managedstream_new,
         // placed here to help seperate in PR
         (void*)sk_managedallocator_new,
-        (void*)sk_managed_pixel_ref_new,
-        (void*)sk_managed_pixel_ref_new_from_existing,
+        (void*)sk_managedpixelref_new,
+        (void*)sk_managedpixelref_new_from_existing,
         (void*)sk_manageddrawable_new,
         (void*)sk_managedtracememorydump_new,
     };
diff --git a/src/xamarin/sk_managedpixelref.cpp b/src/xamarin/sk_managedpixelref.cpp
@@ -7,83 +7,83 @@
 
 #include "include/xamarin/SkManagedPixelRef.h"
 #include "include/xamarin/SkManaged_ID_Change_Listener.h"
-#include "include/xamarin/sk_managed_pixel_ref.h"
+#include "include/xamarin/sk_managedpixelref.h"
 #include "src/c/sk_types_priv.h"
 
-static inline SkManagedPixelRef* AsSkManagedPixelRef(sk_pixel_ref_t* d) {
+static inline SkManagedPixelRef* AsSkManagedPixelRef(sk_pixelref_t* d) {
     return reinterpret_cast<SkManagedPixelRef*>(d);
 }
-static inline sk_pixel_ref_t* ToSkPixelRef(SkManagedPixelRef* d) {
-    return reinterpret_cast<sk_pixel_ref_t*>(d);
+static inline sk_pixelref_t* ToSkPixelRef(SkManagedPixelRef* d) {
+    return reinterpret_cast<sk_pixelref_t*>(d);
 }
 
 static inline SkManaged_ID_Change_Listener* AsSkManaged_ID_Change_Listener(sk_id_change_listener_t* d) {
     return reinterpret_cast<SkManaged_ID_Change_Listener*>(d);
 }
 
-static sk_pixel_ref_procs_t gProcs;
+static sk_pixelref_procs_t gProcs;
 
 void destroy(SkManagedPixelRef* d, void* context) {
     if (gProcs.fDestroy) {
         gProcs.fDestroy(ToSkPixelRef(d), context);
     }
 }
 
-sk_pixel_ref_t* sk_managed_pixel_ref_new_from_existing(void* context, void* pixelRef) {
+sk_pixelref_t* sk_managedpixelref_new_from_existing(void* context, void* pixelRef) {
     return ToSkPixelRef(new SkManagedPixelRef(context, (SkPixelRef*)pixelRef));
 }
 
-sk_pixel_ref_t* sk_managed_pixel_ref_new(
+sk_pixelref_t* sk_managedpixelref_new(
         void* context, int32_t width, int32_t height, void* addr, size_t rowBytes) {
     return ToSkPixelRef(new SkManagedPixelRef(context, width, height, addr, rowBytes));
 }
 
-void sk_managed_pixel_ref_delete(sk_pixel_ref_t* d) {
+void sk_managedpixelref_delete(sk_pixelref_t* d) {
     delete AsSkManagedPixelRef(d);
 }
 
-sk_isize_t sk_managed_pixel_ref_dimensions(sk_pixel_ref_t* d) {
+sk_isize_t sk_managedpixelref_dimensions(sk_pixelref_t* d) {
     return ToISize(AsSkManagedPixelRef(d)->pixelRef->dimensions());
 }
-int32_t sk_managed_pixel_ref_width(sk_pixel_ref_t* d) {
+int32_t sk_managedpixelref_width(sk_pixelref_t* d) {
     return AsSkManagedPixelRef(d)->pixelRef->width();
 }
 
-int32_t sk_managed_pixel_ref_height(sk_pixel_ref_t* d) {
+int32_t sk_managedpixelref_height(sk_pixelref_t* d) {
     return AsSkManagedPixelRef(d)->pixelRef->height();
 }
-size_t sk_managed_pixel_ref_rowBytes(sk_pixel_ref_t* d) {
+size_t sk_managedpixelref_rowBytes(sk_pixelref_t* d) {
     return AsSkManagedPixelRef(d)->pixelRef->rowBytes();
 }
-void* sk_managed_pixel_ref_pixels(sk_pixel_ref_t* d) {
+void* sk_managedpixelref_pixels(sk_pixelref_t* d) {
     return AsSkManagedPixelRef(d)->pixelRef->pixels();
 }
-void* sk_managed_pixel_ref_pixel_ref(sk_pixel_ref_t* d) {
+void* sk_managedpixelref_pixelref(sk_pixelref_t* d) {
     // IMPORTANT!!!
     // we must keep our pixel ref in order to keep functioning
     // so we do not call release() nor unref() on it to prevent it pointing to garbage
     return AsSkManagedPixelRef(d)->pixelRef.get();
 }
-uint32_t sk_managed_pixel_ref_generation_id(sk_pixel_ref_t* d) {
+uint32_t sk_managedpixelref_generation_id(sk_pixelref_t* d) {
     return AsSkManagedPixelRef(d)->pixelRef->getGenerationID();
 }
-void sk_managed_pixel_ref_notify_pixels_changed(sk_pixel_ref_t* d) {
+void sk_managedpixelref_notify_pixels_changed(sk_pixelref_t* d) {
     AsSkManagedPixelRef(d)->pixelRef->notifyPixelsChanged();
 }
-bool sk_managed_pixel_ref_is_immutable(sk_pixel_ref_t* d) {
+bool sk_managedpixelref_is_immutable(sk_pixelref_t* d) {
     return AsSkManagedPixelRef(d)->pixelRef->isImmutable();
 }
-void sk_managed_pixel_ref_set_immutable(sk_pixel_ref_t* d) {
+void sk_managedpixelref_set_immutable(sk_pixelref_t* d) {
     AsSkManagedPixelRef(d)->pixelRef->setImmutable();
 }
-//void sk_managed_pixel_ref_add_generation_id_listener(sk_pixel_ref_t* d, sk_id_change_listener_t* listener) {
+//void sk_managedpixelref_add_generation_id_listener(sk_pixelref_t* d, sk_id_change_listener_t* listener) {
 //    AsSkManagedPixelRef(d)->pixelRef->addGenIDChangeListener(sk_ref_sp(AsSkManaged_ID_Change_Listener(listener)));
 //}
-void sk_managed_pixel_ref_notify_added_to_cache(sk_pixel_ref_t* d) {
+void sk_managedpixelref_notify_added_to_cache(sk_pixelref_t* d) {
     AsSkManagedPixelRef(d)->pixelRef->notifyAddedToCache();
 }
 
-void sk_managed_pixel_ref_set_procs(sk_pixel_ref_procs_t procs) {
+void sk_managedpixelref_set_procs(sk_pixelref_procs_t procs) {
     gProcs = procs;
 
     SkManagedPixelRef::Procs p;

Original file line number	Diff line number	Diff line change
`@@ -138,11 +138,11 @@ bool sk_bitmap_peek_pixels(sk_bitmap_t* cbitmap, sk_pixmap_t* cpixmap) {`
`138`	`138`	`return AsBitmap(cbitmap)->peekPixels(AsPixmap(cpixmap));`
`139`	`139`	`}`
`140`	`140`
`141`		`-SK_C_API void* sk_bitmap_get_pixel_ref(sk_bitmap_t* cbitmap) {`
	`141`	`+SK_C_API void* sk_bitmap_get_pixelref(sk_bitmap_t* cbitmap) {`
`142`	`142`	`return AsBitmap(cbitmap)->pixelRef();`
`143`	`143`	`}`
`144`	`144`
`145`		`-SK_C_API void sk_bitmap_set_pixel_ref(sk_bitmap_t* cbitmap, void* cpixelref, int x, int y) {`
	`145`	`+SK_C_API void sk_bitmap_set_pixelref(sk_bitmap_t* cbitmap, void* cpixelref, int x, int y) {`
`146`	`146`	`SkPixelRef* r = (SkPixelRef*)cpixelref;`
`147`	`147`	`AsBitmap(cbitmap)->setPixelRef(sk_ref_sp(r), x, y);`
`148`	`148`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,83 +7,83 @@`
`7`	`7`
`8`	`8`	`#include "include/xamarin/SkManagedPixelRef.h"`
`9`	`9`	`#include "include/xamarin/SkManaged_ID_Change_Listener.h"`
`10`		`-#include "include/xamarin/sk_managed_pixel_ref.h"`
	`10`	`+#include "include/xamarin/sk_managedpixelref.h"`
`11`	`11`	`#include "src/c/sk_types_priv.h"`
`12`	`12`
`13`		`-static inline SkManagedPixelRef* AsSkManagedPixelRef(sk_pixel_ref_t* d) {`
	`13`	`+static inline SkManagedPixelRef* AsSkManagedPixelRef(sk_pixelref_t* d) {`
`14`	`14`	`return reinterpret_cast<SkManagedPixelRef*>(d);`
`15`	`15`	`}`
`16`		`-static inline sk_pixel_ref_t* ToSkPixelRef(SkManagedPixelRef* d) {`
`17`		`- return reinterpret_cast<sk_pixel_ref_t*>(d);`
	`16`	`+static inline sk_pixelref_t* ToSkPixelRef(SkManagedPixelRef* d) {`
	`17`	`+ return reinterpret_cast<sk_pixelref_t*>(d);`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`static inline SkManaged_ID_Change_Listener* AsSkManaged_ID_Change_Listener(sk_id_change_listener_t* d) {`
`21`	`21`	`return reinterpret_cast<SkManaged_ID_Change_Listener*>(d);`
`22`	`22`	`}`
`23`	`23`
`24`		`-static sk_pixel_ref_procs_t gProcs;`
	`24`	`+static sk_pixelref_procs_t gProcs;`
`25`	`25`
`26`	`26`	`void destroy(SkManagedPixelRef* d, void* context) {`
`27`	`27`	`if (gProcs.fDestroy) {`
`28`	`28`	`gProcs.fDestroy(ToSkPixelRef(d), context);`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`
`32`		`-sk_pixel_ref_t* sk_managed_pixel_ref_new_from_existing(void* context, void* pixelRef) {`
	`32`	`+sk_pixelref_t* sk_managedpixelref_new_from_existing(void* context, void* pixelRef) {`
`33`	`33`	`return ToSkPixelRef(new SkManagedPixelRef(context, (SkPixelRef*)pixelRef));`
`34`	`34`	`}`
`35`	`35`
`36`		`-sk_pixel_ref_t* sk_managed_pixel_ref_new(`
	`36`	`+sk_pixelref_t* sk_managedpixelref_new(`
`37`	`37`	`void* context, int32_t width, int32_t height, void* addr, size_t rowBytes) {`
`38`	`38`	`return ToSkPixelRef(new SkManagedPixelRef(context, width, height, addr, rowBytes));`
`39`	`39`	`}`
`40`	`40`
`41`		`-void sk_managed_pixel_ref_delete(sk_pixel_ref_t* d) {`
	`41`	`+void sk_managedpixelref_delete(sk_pixelref_t* d) {`
`42`	`42`	`delete AsSkManagedPixelRef(d);`
`43`	`43`	`}`
`44`	`44`
`45`		`-sk_isize_t sk_managed_pixel_ref_dimensions(sk_pixel_ref_t* d) {`
	`45`	`+sk_isize_t sk_managedpixelref_dimensions(sk_pixelref_t* d) {`
`46`	`46`	`return ToISize(AsSkManagedPixelRef(d)->pixelRef->dimensions());`
`47`	`47`	`}`
`48`		`-int32_t sk_managed_pixel_ref_width(sk_pixel_ref_t* d) {`
	`48`	`+int32_t sk_managedpixelref_width(sk_pixelref_t* d) {`
`49`	`49`	`return AsSkManagedPixelRef(d)->pixelRef->width();`
`50`	`50`	`}`
`51`	`51`
`52`		`-int32_t sk_managed_pixel_ref_height(sk_pixel_ref_t* d) {`
	`52`	`+int32_t sk_managedpixelref_height(sk_pixelref_t* d) {`
`53`	`53`	`return AsSkManagedPixelRef(d)->pixelRef->height();`
`54`	`54`	`}`
`55`		`-size_t sk_managed_pixel_ref_rowBytes(sk_pixel_ref_t* d) {`
	`55`	`+size_t sk_managedpixelref_rowBytes(sk_pixelref_t* d) {`
`56`	`56`	`return AsSkManagedPixelRef(d)->pixelRef->rowBytes();`
`57`	`57`	`}`
`58`		`-void* sk_managed_pixel_ref_pixels(sk_pixel_ref_t* d) {`
	`58`	`+void* sk_managedpixelref_pixels(sk_pixelref_t* d) {`
`59`	`59`	`return AsSkManagedPixelRef(d)->pixelRef->pixels();`
`60`	`60`	`}`
`61`		`-void* sk_managed_pixel_ref_pixel_ref(sk_pixel_ref_t* d) {`
	`61`	`+void* sk_managedpixelref_pixelref(sk_pixelref_t* d) {`
`62`	`62`	`// IMPORTANT!!!`
`63`	`63`	`// we must keep our pixel ref in order to keep functioning`
`64`	`64`	`// so we do not call release() nor unref() on it to prevent it pointing to garbage`
`65`	`65`	`return AsSkManagedPixelRef(d)->pixelRef.get();`
`66`	`66`	`}`
`67`		`-uint32_t sk_managed_pixel_ref_generation_id(sk_pixel_ref_t* d) {`
	`67`	`+uint32_t sk_managedpixelref_generation_id(sk_pixelref_t* d) {`
`68`	`68`	`return AsSkManagedPixelRef(d)->pixelRef->getGenerationID();`
`69`	`69`	`}`
`70`		`-void sk_managed_pixel_ref_notify_pixels_changed(sk_pixel_ref_t* d) {`
	`70`	`+void sk_managedpixelref_notify_pixels_changed(sk_pixelref_t* d) {`
`71`	`71`	`AsSkManagedPixelRef(d)->pixelRef->notifyPixelsChanged();`
`72`	`72`	`}`
`73`		`-bool sk_managed_pixel_ref_is_immutable(sk_pixel_ref_t* d) {`
	`73`	`+bool sk_managedpixelref_is_immutable(sk_pixelref_t* d) {`
`74`	`74`	`return AsSkManagedPixelRef(d)->pixelRef->isImmutable();`
`75`	`75`	`}`
`76`		`-void sk_managed_pixel_ref_set_immutable(sk_pixel_ref_t* d) {`
	`76`	`+void sk_managedpixelref_set_immutable(sk_pixelref_t* d) {`
`77`	`77`	`AsSkManagedPixelRef(d)->pixelRef->setImmutable();`
`78`	`78`	`}`
`79`		`-//void sk_managed_pixel_ref_add_generation_id_listener(sk_pixel_ref_t* d, sk_id_change_listener_t* listener) {`
	`79`	`+//void sk_managedpixelref_add_generation_id_listener(sk_pixelref_t* d, sk_id_change_listener_t* listener) {`
`80`	`80`	`// AsSkManagedPixelRef(d)->pixelRef->addGenIDChangeListener(sk_ref_sp(AsSkManaged_ID_Change_Listener(listener)));`
`81`	`81`	`//}`
`82`		`-void sk_managed_pixel_ref_notify_added_to_cache(sk_pixel_ref_t* d) {`
	`82`	`+void sk_managedpixelref_notify_added_to_cache(sk_pixelref_t* d) {`
`83`	`83`	`AsSkManagedPixelRef(d)->pixelRef->notifyAddedToCache();`
`84`	`84`	`}`
`85`	`85`
`86`		`-void sk_managed_pixel_ref_set_procs(sk_pixel_ref_procs_t procs) {`
	`86`	`+void sk_managedpixelref_set_procs(sk_pixelref_procs_t procs) {`
`87`	`87`	`gProcs = procs;`
`88`	`88`
`89`	`89`	`SkManagedPixelRef::Procs p;`