[C++11 Allowed Features] Declares a type-safe null pointer converting from NULL to nullptr in src/…

cc/resources/picture.cc

 // Copyright 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 "cc/resources/picture.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 
@@ skipping 27 matching lines @@
 SkData* EncodeBitmap(size_t* offset, const SkBitmap& bm) {
   const int kJpegQuality = 80;
   std::vector<unsigned char> data;
 
   // If bitmap is opaque, encode as JPEG.
   // Otherwise encode as PNG.
   bool encoding_succeeded = false;
   if (bm.isOpaque()) {
     SkAutoLockPixels lock_bitmap(bm);
     if (bm.empty())
-      return NULL;
+      return nullptr;
 
     encoding_succeeded = gfx::JPEGCodec::Encode(
         reinterpret_cast<unsigned char*>(bm.getAddr32(0, 0)),
         gfx::JPEGCodec::FORMAT_SkBitmap,
         bm.width(),
         bm.height(),
         bm.rowBytes(),
         kJpegQuality,
         &data);
   } else {
     encoding_succeeded = gfx::PNGCodec::EncodeBGRASkBitmap(bm, false, &data);
   }
 
   if (encoding_succeeded) {
     *offset = 0;
     return SkData::NewWithCopy(&data.front(), data.size());
   }
-  return NULL;
+  return nullptr;
 }
 
 bool DecodeBitmap(const void* buffer, size_t size, SkBitmap* bm) {
   const unsigned char* data = static_cast<const unsigned char *>(buffer);
 
   // Try PNG first.
   if (gfx::PNGCodec::Decode(data, size, bm))
     return true;
 
   // Try JPEG.
@@ skipping 26 matching lines @@
   : layer_rect_(layer_rect),
     cell_size_(layer_rect.size()) {
   // Instead of recording a trace event for object creation here, we wait for
   // the picture to be recorded in Picture::Record.
 }
 
 scoped_refptr<Picture> Picture::CreateFromSkpValue(const base::Value* value) {
   // Decode the picture from base64.
   std::string encoded;
   if (!value->GetAsString(&encoded))
-    return NULL;
+    return nullptr;
 
   std::string decoded;
   base::Base64Decode(encoded, &decoded);
   SkMemoryStream stream(decoded.data(), decoded.size());
 
   // Read the picture. This creates an empty picture on failure.
   SkPicture* skpicture = SkPicture::CreateFromStream(&stream, &DecodeBitmap);
-  if (skpicture == NULL)
-    return NULL;
+  if (skpicture == nullptr)
+    return nullptr;
 
   gfx::Rect layer_rect(skpicture->width(), skpicture->height());
   return make_scoped_refptr(new Picture(skpicture, layer_rect));
 }
 
 scoped_refptr<Picture> Picture::CreateFromValue(const base::Value* raw_value) {
-  const base::DictionaryValue* value = NULL;
+  const base::DictionaryValue* value = nullptr;
   if (!raw_value->GetAsDictionary(&value))
-    return NULL;
+    return nullptr;
 
   // Decode the picture from base64.
   std::string encoded;
   if (!value->GetString("skp64", &encoded))
-    return NULL;
+    return nullptr;
 
   std::string decoded;
   base::Base64Decode(encoded, &decoded);
   SkMemoryStream stream(decoded.data(), decoded.size());
 
-  const base::Value* layer_rect_value = NULL;
+  const base::Value* layer_rect_value = nullptr;
   if (!value->Get("params.layer_rect", &layer_rect_value))
-    return NULL;
+    return nullptr;
 
   gfx::Rect layer_rect;
   if (!MathUtil::FromValue(layer_rect_value, &layer_rect))
-    return NULL;
+    return nullptr;
 
   // Read the picture. This creates an empty picture on failure.
   SkPicture* skpicture = SkPicture::CreateFromStream(&stream, &DecodeBitmap);
-  if (skpicture == NULL)
-    return NULL;
+  if (skpicture == nullptr)
+    return nullptr;
 
   return make_scoped_refptr(new Picture(skpicture, layer_rect));
 }
 
 Picture::Picture(SkPicture* picture, const gfx::Rect& layer_rect)
     : layer_rect_(layer_rect),
       picture_(skia::AdoptRef(picture)),
       cell_size_(layer_rect.size()) {
 }
 
@@ skipping 12 matching lines @@
 }
 
 bool Picture::IsSuitableForGpuRasterization() const {
   DCHECK(picture_);
 
   // TODO(alokp): SkPicture::suitableForGpuRasterization needs a GrContext.
   // Ideally this GrContext should be the same as that for rasterizing this
   // picture. But we are on the main thread while the rasterization context
   // may be on the compositor or raster thread.
   // SkPicture::suitableForGpuRasterization is not implemented yet.
-  // Pass a NULL context for now and discuss with skia folks if the context
+  // Pass a nullptr context for now and discuss with skia folks if the context
   // is really needed.
-  return picture_->suitableForGpuRasterization(NULL);
+  return picture_->suitableForGpuRasterization(nullptr);
 }
 
 int Picture::ApproximateOpCount() const {
   DCHECK(picture_);
   return picture_->approximateOpCount();
 }
 
 bool Picture::HasText() const {
   DCHECK(picture_);
   return picture_->hasText();
@@ skipping 21 matching lines @@
   canvas = skia::SharePtr(recorder.beginRecording(
       layer_rect_.width(), layer_rect_.height(), &factory));
 
   ContentLayerClient::GraphicsContextStatus graphics_context_status =
       ContentLayerClient::GRAPHICS_CONTEXT_ENABLED;
 
   switch (recording_mode) {
     case RECORD_NORMALLY:
       // Already setup for normal recording.
       break;
-    case RECORD_WITH_SK_NULL_CANVAS:
+    case RECORD_WITH_SK_nullptr_CANVAS:
       canvas = skia::AdoptRef(SkCreateNullCanvas());
       break;
     case RECORD_WITH_PAINTING_DISABLED:
       // We pass a disable flag through the paint calls when perfromance
       // testing (the only time this case should ever arise) when we want to
       // prevent the Blink GraphicsContext object from consuming any compute
       // time.
       canvas = skia::AdoptRef(SkCreateNullCanvas());
       graphics_context_status = ContentLayerClient::GRAPHICS_CONTEXT_DISABLED;
       break;
@@ skipping 144 matching lines @@
 
 scoped_ptr<base::Value> Picture::AsValue() const {
   SkDynamicMemoryWStream stream;
 
   if (playback_) {
     // SkPlayback can't serialize itself, so re-record into an SkPicture.
     SkPictureRecorder recorder;
     skia::RefPtr<SkCanvas> canvas(skia::SharePtr(recorder.beginRecording(
         layer_rect_.width(),
         layer_rect_.height(),
-        NULL)));  // Default (no) bounding-box hierarchy is fastest.
+        nullptr)));  // Default (no) bounding-box hierarchy is fastest.
     playback_->draw(canvas.get());
     skia::RefPtr<SkPicture> picture(skia::AdoptRef(recorder.endRecording()));
     picture->serialize(&stream, &EncodeBitmap);
   } else {
     // Serialize the picture.
     picture_->serialize(&stream, &EncodeBitmap);
   }
 
   // Encode the picture as base64.
   scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue());
@@ skipping 24 matching lines @@
           "devtools.timeline.picture"),
       "cc::Picture",
       this,
       TracedPicture::AsTraceablePictureAlias(original));
 }
 
 base::LazyInstance<Picture::PixelRefs>
     Picture::PixelRefIterator::empty_pixel_refs_;
 
 Picture::PixelRefIterator::PixelRefIterator()
-    : picture_(NULL),
+    : picture_(nullptr),
       current_pixel_refs_(empty_pixel_refs_.Pointer()),
       current_index_(0),
       min_point_(-1, -1),
       max_point_(-1, -1),
       current_x_(0),
       current_y_(0) {
 }
 
 Picture::PixelRefIterator::PixelRefIterator(
     const gfx::Rect& rect,
@@ skipping 96 matching lines @@
   scoped_refptr<base::debug::TracedValue> record_data =
       new base::debug::TracedValue();
   TracedValue::SetIDRef(this, record_data.get(), "picture_id");
   record_data->BeginArray("layer_rect");
   MathUtil::AddToTracedValue(layer_rect_, record_data.get());
   record_data->EndArray();
   return record_data;
 }
 
 }  // namespace cc