color: Clean up dependencies to allow including in cc/paint

ui/gfx/color_space.cc

 // Copyright (c) 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 "ui/gfx/color_space.h"
 
 #include <map>
 #include <sstream>
 
 #include "base/lazy_instance.h"
 #include "base/synchronization/lock.h"
 #include "third_party/skia/include/core/SkColorSpace.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkICC.h"
 #include "ui/gfx/icc_profile.h"
 #include "ui/gfx/skia_color_space_util.h"
-#include "ui/gfx/transform.h"
 
 namespace gfx {
 
 // static
 ColorSpace ColorSpace::CreateVideo(int video_primary,
                                    int video_transfer,
                                    int video_matrix,
                                    RangeID range_id) {
   // TODO(hubbe): Use more context to decide how to handle UNSPECIFIED values.
   ColorSpace result;
@@ skipping 153 matching lines @@
       icc_profile_sk_color_space_(other.icc_profile_sk_color_space_) {
   if (transfer_ == TransferID::CUSTOM) {
     memcpy(custom_transfer_params_, other.custom_transfer_params_,
            sizeof(custom_transfer_params_));
   }
   if (primaries_ == PrimaryID::CUSTOM) {
     memcpy(custom_primary_matrix_, other.custom_primary_matrix_,
            sizeof(custom_primary_matrix_));
   }
 }
+
+ColorSpace::ColorSpace(ColorSpace&& other) = default;
+
+ColorSpace& ColorSpace::operator=(const ColorSpace& other) = default;
+
 ColorSpace::~ColorSpace() = default;
 
 bool ColorSpace::IsValid() const {
   return primaries_ != PrimaryID::INVALID && transfer_ != TransferID::INVALID &&
          matrix_ != MatrixID::INVALID && range_ != RangeID::INVALID;
 }
 
 // static
 ColorSpace ColorSpace::CreateSRGB() {
   return ColorSpace(PrimaryID::BT709, TransferID::IEC61966_2_1, MatrixID::RGB,
@@ skipping 124 matching lines @@
         memcmp(custom_transfer_params_, other.custom_transfer_params_,
                sizeof(custom_transfer_params_));
     if (transfer_result < 0)
       return true;
     if (transfer_result > 0)
       return false;
   }
   return false;
 }
 
+size_t ColorSpace::GetHash() const {
+  size_t result = (static_cast<size_t>(primaries_) << 0) |
+                  (static_cast<size_t>(transfer_) << 8) |
+                  (static_cast<size_t>(matrix_) << 16) |
+                  (static_cast<size_t>(range_) << 24);
+  if (primaries_ == PrimaryID::CUSTOM) {
+    const uint32_t* params =
+        reinterpret_cast<const uint32_t*>(custom_primary_matrix_);
+    result ^= params[0];
+    result ^= params[4];
+    result ^= params[8];
+  }
+  if (transfer_ == TransferID::CUSTOM) {
+    const uint32_t* params =
+        reinterpret_cast<const uint32_t*>(custom_transfer_params_);
+    result ^= params[3];
+    result ^= params[6];
+  }
+  return result;
+}
+
 std::string ColorSpace::ToString() const {
   std::stringstream ss;
   ss << "{primaries:";
   if (primaries_ == PrimaryID::CUSTOM) {
     ss << "[";
     for (size_t i = 0; i < 3; ++i) {
       ss << "[";
       for (size_t j = 0; j < 3; ++j) {
         ss << custom_primary_matrix_[3 * i + j];
         ss << ",";
@@ skipping 467 matching lines @@
       matrix->postTranslate(-16.0f/219.0f, -15.5f/224.0f, -15.5f/224.0f);
       break;
   }
 }
 
 std::ostream& operator<<(std::ostream& out, const ColorSpace& color_space) {
   return out << color_space.ToString();
 }
 
 }  // namespace gfx