Revert of Lots of progress switching to SkColorSpace rather than SkColorProfileType

bench/nanobench.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <ctype.h>
 
 #include "nanobench.h"
@@ skipping 406 matching lines @@
         } else {
             SkDebugf("No context was available matching config type and options.\n");
             return;
         }
 
         Config target = {
             gpuConfig->getTag(),
             Benchmark::kGPU_Backend,
             kN32_SkColorType,
             kPremul_SkAlphaType,
-            nullptr,
+            kLinear_SkColorProfileType,
             sampleCount,
             ctxType,
             ctxOptions,
             gpuConfig->getUseDIText()
         };
 
         configs->push_back(target);
         return;
     }
 #endif
 
-    #define CPU_CONFIG(name, backend, color, alpha, colorSpace)                \
-        if (config->getTag().equals(#name)) {                                  \
-            Config config = {                                                  \
-                SkString(#name), Benchmark::backend, color, alpha, colorSpace, \
-                0, kBogusContextType, kBogusContextOptions, false              \
-            };                                                                 \
-            configs->push_back(config);                                        \
-            return;                                                            \
+    #define CPU_CONFIG(name, backend, color, alpha, profile)                 \
+        if (config->getTag().equals(#name)) {                                \
+            Config config = {                                                \
+                SkString(#name), Benchmark::backend, color, alpha, profile,  \
+                0, kBogusContextType, kBogusContextOptions, false            \
+            };                                                               \
+            configs->push_back(config);                                      \
+            return;                                                          \
         }
 
     if (FLAGS_cpu) {
         CPU_CONFIG(nonrendering, kNonRendering_Backend,
-                   kUnknown_SkColorType, kUnpremul_SkAlphaType, nullptr)
+                   kUnknown_SkColorType, kUnpremul_SkAlphaType, kLinear_SkColorProfileType);
 
         CPU_CONFIG(8888, kRaster_Backend,
-                   kN32_SkColorType, kPremul_SkAlphaType, nullptr)
+                   kN32_SkColorType, kPremul_SkAlphaType, kLinear_SkColorProfileType)
         CPU_CONFIG(565,  kRaster_Backend,
-                   kRGB_565_SkColorType, kOpaque_SkAlphaType, nullptr)
-        auto srgbColorSpace = SkColorSpace::NewNamed(SkColorSpace::kSRGB_Named);
+                   kRGB_565_SkColorType, kOpaque_SkAlphaType, kLinear_SkColorProfileType)
         CPU_CONFIG(srgb, kRaster_Backend,
-                   kN32_SkColorType,  kPremul_SkAlphaType, srgbColorSpace)
+                   kN32_SkColorType,  kPremul_SkAlphaType, kSRGB_SkColorProfileType)
         CPU_CONFIG(f16,  kRaster_Backend,
-                   kRGBA_F16_SkColorType, kPremul_SkAlphaType, nullptr)
+                   kRGBA_F16_SkColorType, kPremul_SkAlphaType, kLinear_SkColorProfileType)
     }
 
     #undef CPU_CONFIG
 
 #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
     if (config->getTag().equals("hwui")) {
         Config config = { SkString("hwui"), Benchmark::kHWUI_Backend,
-                          kRGBA_8888_SkColorType, kPremul_SkAlphaType, nullptr,
+                          kRGBA_8888_SkColorType, kPremul_SkAlphaType, kLinear_SkColorProfileType,
                           0, kBogusContextType, kBogusContextOptions, false };
         configs->push_back(config);
     }
 #endif
 }
 
 // Append all configs that are enabled and supported.
 void create_configs(SkTArray<Config>* configs) {
     SkCommandLineConfigArray array;
     ParseConfigs(FLAGS_config, &array);
     for (int i = 0; i < array.count(); ++i) {
         create_config(array[i], configs);
     }
 }
 
 // If bench is enabled for config, returns a Target* for it, otherwise nullptr.
 static Target* is_enabled(Benchmark* bench, const Config& config) {
     if (!bench->isSuitableFor(config.backend)) {
         return nullptr;
     }
 
     SkImageInfo info = SkImageInfo::Make(bench->getSize().fX, bench->getSize().fY,
-                                         config.color, config.alpha, config.colorSpace);
+                                         config.color, config.alpha, config.profile);
 
     Target* target = nullptr;
 
     switch (config.backend) {
 #if SK_SUPPORT_GPU
     case Benchmark::kGPU_Backend:
         target = new GPUTarget(config);
         break;
 #endif
 #ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
@@ skipping 785 matching lines @@
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char** argv) {
     SkCommandLineFlags::Parse(argc, argv);
     return nanobench_main();
 }
 #endif