Replace all the string literals in core/frame/ImageBitmap.cpp with constants

third_party/WebKit/Source/core/frame/ImageBitmap.cpp

 // Copyright 2013 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 "core/frame/ImageBitmap.h"
 
 #include "core/html/Float32ImageData.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/ImageData.h"
 #include "core/offscreencanvas/OffscreenCanvas.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "platform/image-decoders/ImageDecoder.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkImageInfo.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "wtf/CheckedNumeric.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/RefPtr.h"
 #include <memory>
 
 namespace blink {
 
-static const char* imageOrientationFlipY = "flipY";
-static const char* imageBitmapOptionNone = "none";
+const char* const kImageOrientationFlipY = "flipY";

[dcheng, 2017/01/26 19:27:51]

Nit: constexpr char kImageOrientationFlip = "...";

ditto for the rest

[zakerinasab1, 2017/01/26 20:48:42]

Done.

+const char* const kImageBitmapOptionNone = "none";
+const char* const kImageBitmapOptionDefault = "default";
+const char* const kImageBitmapOptionPremultiply = "premultiply";
+const char* const kImageBitmapOptionResizeQualityHigh = "high";
+const char* const kImageBitmapOptionResizeQualityMedium = "medium";
+const char* const kImageBitmapOptionResizeQualityPixelated = "pixelated";
+const char* const kSRGBImageBitmapColorSpaceConversion = "srgb";
+const char* const kLinearRGBImageBitmapColorSpaceConversion = "linear-rgb";
 
 namespace {
 
 struct ParsedOptions {
   bool flipY = false;
   bool premultiplyAlpha = true;
   bool shouldScaleInput = false;
   unsigned resizeWidth = 0;
   unsigned resizeHeight = 0;
   IntRect cropRect;
@@ skipping 13 matching lines @@
   return IntRect(std::min(rect.x(), rect.maxX()),
                  std::min(rect.y(), rect.maxY()),
                  std::max(rect.width(), -rect.width()),
                  std::max(rect.height(), -rect.height()));
 }
 
 ParsedOptions parseOptions(const ImageBitmapOptions& options,
                            Optional<IntRect> cropRect,
                            IntSize sourceSize) {
   ParsedOptions parsedOptions;
-  if (options.imageOrientation() == imageOrientationFlipY) {
+  if (options.imageOrientation() == kImageOrientationFlipY) {
     parsedOptions.flipY = true;
   } else {
     parsedOptions.flipY = false;
-    DCHECK(options.imageOrientation() == imageBitmapOptionNone);
+    DCHECK(options.imageOrientation() == kImageBitmapOptionNone);
   }
-  if (options.premultiplyAlpha() == imageBitmapOptionNone) {
+  if (options.premultiplyAlpha() == kImageBitmapOptionNone) {
     parsedOptions.premultiplyAlpha = false;
   } else {
     parsedOptions.premultiplyAlpha = true;
-    DCHECK(options.premultiplyAlpha() == "default" ||
-           options.premultiplyAlpha() == "premultiply");
+    DCHECK(options.premultiplyAlpha() == kImageBitmapOptionDefault ||
+           options.premultiplyAlpha() == kImageBitmapOptionPremultiply);
   }
 
-  if (options.colorSpaceConversion() != imageBitmapOptionNone) {
+  if (options.colorSpaceConversion() != kImageBitmapOptionNone) {
     if (!RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled() ||
         !RuntimeEnabledFeatures::colorCorrectRenderingEnabled()) {
-      DCHECK_EQ(options.colorSpaceConversion(), "default");
+      DCHECK_EQ(options.colorSpaceConversion(), kImageBitmapOptionDefault);
       if (RuntimeEnabledFeatures::colorCorrectRenderingDefaultModeEnabled()) {
         parsedOptions.dstColorSpace = ColorBehavior::globalTargetColorSpace();
         parsedOptions.dstColorType = SkColorType::kN32_SkColorType;
       }
     } else {
-      if (options.colorSpaceConversion() == "default" ||
-          options.colorSpaceConversion() == "srgb") {
+      if (options.colorSpaceConversion() == kImageBitmapOptionDefault ||
+          options.colorSpaceConversion() ==
+              kSRGBImageBitmapColorSpaceConversion) {
         parsedOptions.dstColorSpace =
             SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named);
         parsedOptions.dstColorType = SkColorType::kN32_SkColorType;
-      } else if (options.colorSpaceConversion() == "linear-rgb") {
+      } else if (options.colorSpaceConversion() ==
+                 kLinearRGBImageBitmapColorSpaceConversion) {
         parsedOptions.dstColorSpace =
             SkColorSpace::MakeNamed(SkColorSpace::kSRGBLinear_Named);
         parsedOptions.dstColorType = SkColorType::kRGBA_F16_SkColorType;
       } else {
         NOTREACHED()
             << "Invalid ImageBitmap creation attribute colorSpaceConversion: "
             << options.colorSpaceConversion();
       }
     }
   }
@@ skipping 24 matching lines @@
   }
   if (static_cast<int>(parsedOptions.resizeWidth) ==
           parsedOptions.cropRect.width() &&
       static_cast<int>(parsedOptions.resizeHeight) ==
           parsedOptions.cropRect.height()) {
     parsedOptions.shouldScaleInput = false;
     return parsedOptions;
   }
   parsedOptions.shouldScaleInput = true;
 
-  if (options.resizeQuality() == "high")
+  if (options.resizeQuality() == kImageBitmapOptionResizeQualityHigh)
     parsedOptions.resizeQuality = kHigh_SkFilterQuality;
-  else if (options.resizeQuality() == "medium")
+  else if (options.resizeQuality() == kImageBitmapOptionResizeQualityMedium)
     parsedOptions.resizeQuality = kMedium_SkFilterQuality;
-  else if (options.resizeQuality() == "pixelated")
+  else if (options.resizeQuality() == kImageBitmapOptionResizeQualityPixelated)
     parsedOptions.resizeQuality = kNone_SkFilterQuality;
   else
     parsedOptions.resizeQuality = kLow_SkFilterQuality;
   return parsedOptions;
 }
 
 bool dstBufferSizeHasOverflow(const ParsedOptions& options) {
   CheckedNumeric<unsigned> totalBytes = options.cropRect.width();
   totalBytes *= options.cropRect.height();
   totalBytes *= SkColorTypeBytesPerPixel(options.latestColorType);
@@ skipping 403 matching lines @@
 ImageBitmap::ImageBitmap(HTMLImageElement* image,
                          Optional<IntRect> cropRect,
                          Document* document,
                          const ImageBitmapOptions& options) {
   RefPtr<Image> input = image->cachedImage()->getImage();
   ParsedOptions parsedOptions =
       parseOptions(options, cropRect, image->bitmapSourceSize());
   if (dstBufferSizeHasOverflow(parsedOptions))
     return;
 
-  if (options.colorSpaceConversion() == imageBitmapOptionNone) {
+  if (options.colorSpaceConversion() == kImageBitmapOptionNone) {
     m_image = cropImageAndApplyColorSpaceConversion(
         input.get(), parsedOptions, PremultiplyAlpha, ColorBehavior::ignore());
   } else {
     m_image = cropImageAndApplyColorSpaceConversion(
         input.get(), parsedOptions, PremultiplyAlpha,
         ColorBehavior::transformToGlobalTarget());
   }
 
   if (!m_image)
     return;
@@ skipping 573 matching lines @@
 void ImageBitmap::adjustDrawRects(FloatRect* srcRect,
                                   FloatRect* dstRect) const {}
 
 FloatSize ImageBitmap::elementSize(const FloatSize&) const {
   return FloatSize(width(), height());
 }
 
 DEFINE_TRACE(ImageBitmap) {}
 
 }  // namespace blink