Revert of Lots of progress switching to SkColorSpace rather than SkColorProfileType

tools/flags/SkCommonFlagsConfig.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 "SkCommonFlagsConfig.h"
 
 #include <stdlib.h>
@@ skipping 174 matching lines @@
         , fBackend(backend)
         , fViaParts(viaParts) {
 }
 SkCommandLineConfig::~SkCommandLineConfig() {
 }
 
 #if SK_SUPPORT_GPU
 SkCommandLineConfigGpu::SkCommandLineConfigGpu(
     const SkString& tag, const SkTArray<SkString>& viaParts,
     ContextType contextType, bool useNVPR, bool useDIText, int samples,
-    SkColorType colorType, sk_sp<SkColorSpace> colorSpace)
+    SkColorType colorType, SkColorProfileType profileType)
         : SkCommandLineConfig(tag, SkString("gpu"), viaParts)
         , fContextType(contextType)
         , fUseNVPR(useNVPR)
         , fUseDIText(useDIText)
         , fSamples(samples)
         , fColorType(colorType)
-        , fColorSpace(std::move(colorSpace)) {
+        , fProfileType(profileType) {
 }
 static bool parse_option_int(const SkString& value, int* outInt) {
     if (value.isEmpty()) {
         return false;
     }
     char* endptr = nullptr;
     long intValue = strtol(value.c_str(), &endptr, 10);
     if (*endptr != '\0') {
         return false;
     }
@@ skipping 56 matching lines @@
 #ifdef SK_VULKAN
     if (value.equals("vulkan")) {
         *outContextType = GrContextFactory::kVulkan_ContextType;
         return true;
     }
 #endif
     return false;
 }
 static bool parse_option_gpu_color(const SkString& value,
                                    SkColorType* outColorType,
-                                   sk_sp<SkColorSpace>* outColorSpace) {
+                                   SkColorProfileType* outProfileType) {
     if (value.equals("8888")) {
         *outColorType = kN32_SkColorType;
-        *outColorSpace = nullptr;
+        *outProfileType = kLinear_SkColorProfileType;
         return true;
     }
     if (value.equals("f16")) {
         *outColorType = kRGBA_F16_SkColorType;
-        *outColorSpace = nullptr;
+        *outProfileType = kLinear_SkColorProfileType;
         return true;
     }
     if (value.equals("srgb")) {
         *outColorType = kN32_SkColorType;
-        *outColorSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named);
+        *outProfileType = kSRGB_SkColorProfileType;
         return true;
     }
     return false;
 }
 
 SkCommandLineConfigGpu* parse_command_line_config_gpu(const SkString& tag,
                                                       const SkTArray<SkString>& vias,
                                                       const SkString& options) {
     // Defaults for GPU backend.
     bool seenAPI = false;
     SkCommandLineConfigGpu::ContextType contextType = GrContextFactory::kNativeGL_ContextType;
     bool seenUseNVPR = false;
     bool useNVPR = false;
     bool seenUseDIText =false;
     bool useDIText = false;
     bool seenSamples = false;
     int samples = 0;
     bool seenColor = false;
     SkColorType colorType = kN32_SkColorType;
-    sk_sp<SkColorSpace> colorSpace = nullptr;
+    SkColorProfileType profileType = kLinear_SkColorProfileType;
 
     SkTArray<SkString> optionParts;
     SkStrSplit(options.c_str(), ",", kStrict_SkStrSplitMode, &optionParts);
     for (int i = 0; i < optionParts.count(); ++i) {
         SkTArray<SkString> keyValueParts;
         SkStrSplit(optionParts[i].c_str(), "=", kStrict_SkStrSplitMode, &keyValueParts);
         if (keyValueParts.count() != 2) {
             return nullptr;
         }
         const SkString& key = keyValueParts[0];
         const SkString& value = keyValueParts[1];
         bool valueOk = false;
         if (key.equals("api") && !seenAPI) {
             valueOk = parse_option_gpu_api(value, &contextType);
             seenAPI = true;
         } else if (key.equals("nvpr") && !seenUseNVPR) {
             valueOk = parse_option_bool(value, &useNVPR);
             seenUseNVPR = true;
         } else if (key.equals("dit") && !seenUseDIText) {
             valueOk = parse_option_bool(value, &useDIText);
             seenUseDIText = true;
         } else if (key.equals("samples") && !seenSamples) {
             valueOk = parse_option_int(value, &samples);
             seenSamples = true;
         } else if (key.equals("color") && !seenColor) {
-            valueOk = parse_option_gpu_color(value, &colorType, &colorSpace);
+            valueOk = parse_option_gpu_color(value, &colorType, &profileType);
             seenColor = true;
         }
         if (!valueOk) {
             return nullptr;
         }
     }
     return new SkCommandLineConfigGpu(tag, vias, contextType, useNVPR, useDIText, samples,
-                                      colorType, colorSpace);
+                                      colorType, profileType);
 }
 #endif
 
 void ParseConfigs(const SkCommandLineFlags::StringArray& configs,
                   SkCommandLineConfigArray* outResult) {
     outResult->reset();
     for (int i = 0; i < configs.count(); ++i) {
         SkString extendedBackend;
         SkString extendedOptions;
         SkString simpleBackend;
@@ skipping 45 matching lines @@
         if (extendedBackend.equals("gpu")) {
             parsedConfig = parse_command_line_config_gpu(tag, vias, extendedOptions);
         }
 #endif
         if (!parsedConfig) {
             parsedConfig = new SkCommandLineConfig(tag, simpleBackend, vias);
         }
         outResult->emplace_back(parsedConfig);
     }
 }