Style Change: NULL->nullptr

site/dev/contrib/style.md

 Coding Style Guidelines
 =======================
 
 These conventions have evolved over time. Some of the earlier code in both
 projects doesn’t strictly adhere to the guidelines. However, as the code evolves
 we hope to make the existing code conform to the guildelines.
 
 Files
 -----
 
@@ skipping 422 matching lines @@
 
 We follow the Google C++ guide for ints and are slowly making older code conform to this
 
 (http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Integer_Types)
 
 Summary: Use int unless you have need a guarantee on the bit count, then use
 stdint.h types (int32_t, etc). Assert that counts, etc are not negative instead
 of using unsigned. Bitfields use uint32_t unless they have to be made shorter
 for packing or performance reasons.
 
-NULL, 0
+nullptr, 0
 -------
 
-Use NULL for pointers, 0 for ints. We prefer explicit NULL comparisons when
-checking for NULL pointers (as documentation):
+Use nullptr for pointers, 0 for ints. We prefer explicit nullptr comparisons when
+checking for nullptr pointers (as documentation):
 
 <!--?prettify?-->
 ~~~~
-if (NULL == x) {  // slightly preferred over if (!x)
+if (nullptr == x) {  // slightly preferred over if (!x)
    ...
 }
 ~~~~
 
-When checking non-NULL pointers explicit comparisons are not required because it
+When checking non-nullptr pointers explicit comparisons are not required because it
 reads like a double negative:
 
 <!--?prettify?-->
 ~~~~
-if (x) {  // slightly preferred over if (NULL != x)
+if (x) {  // slightly preferred over if (nullptr != x)
    ...
 }
 ~~~~
 
 Returning structs
 -----------------
 
 If the desired behavior is for a function to return a struct, we prefer using a
 struct as an output parameter
 
@@ skipping 35 matching lines @@
 Mandatory constant object parameters are passed to functions as const references
 if they are not retained by the receiving function. Optional constant object
 parameters are passed to functions as const pointers. Objects that the called
 function will retain, either directly or indirectly, are passed as pointers.
 Variable (i.e. mutable) object parameters are passed to functions as pointers.
 
 <!--?prettify?-->
 ~~~~
 // src and paint are optional
 void SkCanvas::drawBitmapRect(const SkBitmap& bitmap, const SkIRect* src, 
-                             const SkRect& dst, const SkPaint* paint = NULL);
+                             const SkRect& dst, const SkPaint* paint = nullptr);
 // metrics is mutable (it is changed by the method)
 SkScalar SkPaint::getFontMetrics(FontMetric* metrics, SkScalar scale) const;
 // A reference to foo is retained by SkContainer
 void SkContainer::insert(const SkFoo* foo);
 ~~~~
 
 If function arguments or parameters do not all fit on one line, they may be
 lined up with the first parameter on the same line
 
 <!--?prettify?-->
 ~~~~
 void drawBitmapRect(const SkBitmap& bitmap, const SkRect& dst,
-                    const SkPaint* paint = NULL) {
-    this->drawBitmapRectToRect(bitmap, NULL, dst, paint,
+                    const SkPaint* paint = nullptr) {
+    this->drawBitmapRectToRect(bitmap, nullptr, dst, paint,
                                kNone_DrawBitmapRectFlag);
 }
 ~~~~
 
 or placed on the next line indented eight spaces
 
 <!--?prettify?-->
 ~~~~
 void drawBitmapRect(
         const SkBitmap& bitmap, const SkRect& dst,
-        const SkPaint* paint = NULL) {
+        const SkPaint* paint = nullptr) {
     this->drawBitmapRectToRect(
-            bitmap, NULL, dst, paint, kNone_DrawBitmapRectFlag);
+            bitmap, nullptr, dst, paint, kNone_DrawBitmapRectFlag);
 }
 ~~~~
 
 Python
 ------
 
 Python code follows the [Google Python Style Guide](http://google-styleguide.googlecode.com/svn/trunk/pyguide.html).