no need for newlines in DM Errors

dm/DMSrcSink.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "DMSrcSink.h"
 #include "SamplePipeControllers.h"
 #include "SkAndroidCodec.h"
@@ skipping 95 matching lines @@
             colorType = kGray_8_SkColorType;
             break;
     }
 
     SkAutoTDelete<SkBitmapRegionDecoder> brd(create_brd(fPath, fStrategy));
     if (nullptr == brd.get()) {
         return Error::Nonfatal(SkStringPrintf("Could not create brd for %s.", fPath.c_str()));
     }
 
     if (!brd->conversionSupported(colorType)) {
-        return Error::Nonfatal("Cannot convert to color type.\n");
+        return Error::Nonfatal("Cannot convert to color type.");
     }
 
     const uint32_t width = brd->width();
     const uint32_t height = brd->height();
     // Visually inspecting very small output images is not necessary.
     if ((width / fSampleSize <= 10 || height / fSampleSize <= 10) && 1 != fSampleSize) {
         return Error::Nonfatal("Scaling very small images is uninteresting.");
     }
     switch (fMode) {
         case kFullImage_Mode: {
             SkBitmap bitmap;
             if (!brd->decodeRegion(&bitmap, nullptr, SkIRect::MakeXYWH(0, 0, width, height),
                     fSampleSize, colorType, false)) {
-                return "Cannot decode (full) region.\n";
+                return "Cannot decode (full) region.";
             }
             if (colorType != bitmap.colorType()) {
-                return Error::Nonfatal("Cannot convert to color type.\n");
+                return Error::Nonfatal("Cannot convert to color type.");
             }
             canvas->drawBitmap(bitmap, 0, 0);
             return "";
         }
         case kDivisor_Mode: {
             const uint32_t divisor = 2;
             if (width < divisor || height < divisor) {
-                return Error::Nonfatal("Divisor is larger than image dimension.\n");
+                return Error::Nonfatal("Divisor is larger than image dimension.");
             }
 
             // Use a border to test subsets that extend outside the image.
             // We will not allow the border to be larger than the image dimensions.  Allowing
             // these large borders causes off by one errors that indicate a problem with the
             // test suite, not a problem with the implementation.
             const uint32_t maxBorder = SkTMin(width, height) / (fSampleSize * divisor);
             const uint32_t scaledBorder = SkTMin(5u, maxBorder);
             const uint32_t unscaledBorder = scaledBorder * fSampleSize;
 
@@ skipping 24 matching lines @@
                     subsetHeight += (y + 1 == divisor) ? (height % divisor) : 0;
 
                     // Increase the size of the subset in order to have a border on each side
                     const int decodeLeft = left - unscaledBorder;
                     const int decodeTop = top - unscaledBorder;
                     const uint32_t decodeWidth = subsetWidth + unscaledBorder * 2;
                     const uint32_t decodeHeight = subsetHeight + unscaledBorder * 2;
                     SkBitmap bitmap;
                     if (!brd->decodeRegion(&bitmap, nullptr, SkIRect::MakeXYWH(decodeLeft,
                             decodeTop, decodeWidth, decodeHeight), fSampleSize, colorType, false)) {
-                        return "Cannot decode region.\n";
+                        return "Cannot decode region.";
                     }
                     if (colorType != bitmap.colorType()) {
-                        return Error::Nonfatal("Cannot convert to color type.\n");
+                        return Error::Nonfatal("Cannot convert to color type.");
                     }
 
                     canvas->drawBitmapRect(bitmap,
                             SkRect::MakeXYWH((SkScalar) scaledBorder, (SkScalar) scaledBorder,
                                     (SkScalar) (subsetWidth / fSampleSize),
                                     (SkScalar) (subsetHeight / fSampleSize)),
                             SkRect::MakeXYWH((SkScalar) (left / fSampleSize),
                                     (SkScalar) (top / fSampleSize),
                                     (SkScalar) (subsetWidth / fSampleSize),
                                     (SkScalar) (subsetHeight / fSampleSize)),
                             nullptr);
                 }
             }
             return "";
         }
         default:
             SkASSERT(false);
-            return "Error: Should not be reached.\n";
+            return "Error: Should not be reached.";
     }
 }
 
 SkISize BRDSrc::size() const {
     SkAutoTDelete<SkBitmapRegionDecoder> brd(create_brd(fPath, fStrategy));
     if (brd) {
         return SkISize::Make(SkTMax(1, brd->width() / (int) fSampleSize),
                 SkTMax(1, brd->height() / (int) fSampleSize));
     }
     return SkISize::Make(0, 0);
@@ skipping 92 matching lines @@
     int maxColors = 256;
     if (kIndex_8_SkColorType == decodeInfo.colorType()) {
         SkPMColor colors[256];
         colorTable.reset(new SkColorTable(colors, maxColors));
         colorPtr = const_cast<SkPMColor*>(colorTable->readColors());
         colorCountPtr = &maxColors;
     }
 
     SkBitmap bitmap;
     if (!bitmap.tryAllocPixels(decodeInfo, nullptr, colorTable.get())) {
-        return SkStringPrintf("Image(%s) is too large (%d x %d)\n", fPath.c_str(),
+        return SkStringPrintf("Image(%s) is too large (%d x %d)", fPath.c_str(),
                               decodeInfo.width(), decodeInfo.height());
     }
 
     switch (fMode) {
         case kCodec_Mode: {
             switch (codec->getPixels(decodeInfo, bitmap.getPixels(), bitmap.rowBytes(), nullptr,
                     colorPtr, colorCountPtr)) {
                 case SkCodec::kSuccess:
                     // We consider incomplete to be valid, since we should still decode what is
                     // available.
@@ skipping 241 matching lines @@
     int maxColors = 256;
     if (kIndex_8_SkColorType == decodeInfo.colorType()) {
         SkPMColor colors[256];
         colorTable.reset(new SkColorTable(colors, maxColors));
         colorPtr = const_cast<SkPMColor*>(colorTable->readColors());
         colorCountPtr = &maxColors;
     }
 
     SkBitmap bitmap;
     if (!bitmap.tryAllocPixels(decodeInfo, nullptr, colorTable.get())) {
-        return SkStringPrintf("Image(%s) is too large (%d x %d)\n", fPath.c_str(),
+        return SkStringPrintf("Image(%s) is too large (%d x %d)", fPath.c_str(),
                               decodeInfo.width(), decodeInfo.height());
     }
 
     // Create options for the codec.
     SkAndroidCodec::AndroidOptions options;
     options.fColorPtr = colorPtr;
     options.fColorCount = colorCountPtr;
     options.fSampleSize = fSampleSize;
 
     switch (fMode) {
         case kFullImage_Mode: {
             switch (codec->getAndroidPixels(decodeInfo, bitmap.getPixels(), bitmap.rowBytes(),
                     &options)) {
                 case SkCodec::kSuccess:
                 case SkCodec::kIncompleteInput:
                     break;
                 case SkCodec::kInvalidConversion:
-                    return Error::Nonfatal("Cannot convert to requested color type.\n");
+                    return Error::Nonfatal("Cannot convert to requested color type.");
                 default:
                     return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
             }
             canvas->drawBitmap(bitmap, 0, 0);
             return "";
         }
         case kDivisor_Mode: {
             const int width = codec->getInfo().width();
             const int height = codec->getInfo().height();
             const int divisor = 2;
             if (width < divisor || height < divisor) {
-                return Error::Nonfatal("Divisor is larger than image dimension.\n");
+                return Error::Nonfatal("Divisor is larger than image dimension.");
             }
 
             // Keep track of the final decoded dimensions.
             int finalScaledWidth = 0;
             int finalScaledHeight = 0;
             for (int x = 0; x < divisor; x++) {
                 for (int y = 0; y < divisor; y++) {
                     // Calculate the subset dimensions
                     int subsetWidth = width / divisor;
                     int subsetHeight = height / divisor;
                     const int left = x * subsetWidth;
                     const int top = y * subsetHeight;
 
                     // Increase the size of the last subset in each row or column, when the
                     // divisor does not divide evenly into the image dimensions
                     subsetWidth += (x + 1 == divisor) ? (width % divisor) : 0;
                     subsetHeight += (y + 1 == divisor) ? (height % divisor) : 0;
                     SkIRect subset = SkIRect::MakeXYWH(left, top, subsetWidth, subsetHeight);
                     if (!codec->getSupportedSubset(&subset)) {
-                        return "Could not get supported subset to decode.\n";
+                        return "Could not get supported subset to decode.";
                     }
                     options.fSubset = &subset;
                     const int scaledWidthOffset = subset.left() / fSampleSize;
                     const int scaledHeightOffset = subset.top() / fSampleSize;
                     void* pixels = bitmap.getAddr(scaledWidthOffset, scaledHeightOffset);
                     SkISize scaledSubsetSize = codec->getSampledSubsetDimensions(fSampleSize,
                             subset);
                     SkImageInfo subsetDecodeInfo = decodeInfo.makeWH(scaledSubsetSize.width(),
                             scaledSubsetSize.height());
 
                     if (x + 1 == divisor && y + 1 == divisor) {
                         finalScaledWidth = scaledWidthOffset + scaledSubsetSize.width();
                         finalScaledHeight = scaledHeightOffset + scaledSubsetSize.height();
                     }
 
                     switch (codec->getAndroidPixels(subsetDecodeInfo, pixels, bitmap.rowBytes(),
                             &options)) {
                         case SkCodec::kSuccess:
                         case SkCodec::kIncompleteInput:
                             break;
                         case SkCodec::kInvalidConversion:
-                            return Error::Nonfatal("Cannot convert to requested color type.\n");
+                            return Error::Nonfatal("Cannot convert to requested color type.");
                         default:
                             return SkStringPrintf("Couldn't getPixels %s.", fPath.c_str());
                     }
                 }
             }
 
             SkRect rect = SkRect::MakeXYWH(0, 0, (SkScalar) finalScaledWidth,
                     (SkScalar) finalScaledHeight);
             canvas->drawBitmapRect(bitmap, rect, rect, nullptr);
             return "";
         }
         default:
             SkASSERT(false);
-            return "Error: Should not be reached.\n";
+            return "Error: Should not be reached.";
     }
 }
 
 SkISize AndroidCodecSrc::size() const {
     SkAutoTUnref<SkData> encoded(SkData::NewFromFileName(fPath.c_str()));
     SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromData(encoded));
     if (nullptr == codec) {
         return SkISize::Make(0, 0);
     }
     return codec->getSampledDimensions(fSampleSize);
@@ skipping 585 matching lines @@
             skr.visit<void>(i, drawsAsSingletonPictures);
         }
         SkAutoTUnref<SkPicture> macroPic(macroRec.endRecordingAsPicture());
 
         canvas->drawPicture(macroPic);
         return "";
     });
 }
 
 }  // namespace DM