Respect colorSpace in DecodingImageGenerator::onGetPixels()

third_party/WebKit/Source/platform/wtf/HashFunctions.h

 /*
  * Copyright (C) 2005, 2006, 2008 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 266 matching lines @@
 struct PairHash
     : PairHashImpl<T,
                    U,
                    std::is_integral<T>::value && std::is_integral<U>::value> {};
 
 template <typename T, typename U>
 struct DefaultHash<std::pair<T, U>> {
   using Hash = PairHash<T, U>;
 };
 
+template <typename T, typename U, typename V>
+struct TupleHash {

[Nico, 2017/04/11 15:41:05]

If we must have a TupleHash, consider making it a variadic template. But often,
a struct with named members is much nicer than using tuples  a lot.

[msarett1, 2017/04/11 20:52:05]

Seems fine to write a custom hashing implementation for this Key.  I've done
this.  Removed all changes to platform/wtf.

+  static unsigned GetHash(const std::tuple<T, U, V>& p) {
+    return HashInts(HashInts(DefaultHash<T>::Hash::GetHash(std::get<0>(p)),
+                             DefaultHash<U>::Hash::GetHash(std::get<1>(p))),
+                    DefaultHash<V>::Hash::GetHash(std::get<2>(p)));
+  }
+  static bool Equal(const std::tuple<T, U, V>& a,
+                    const std::tuple<T, U, V>& b) {
+    return DefaultHash<T>::Hash::Equal(std::get<0>(a), std::get<0>(b)) &&
+           DefaultHash<U>::Hash::Equal(std::get<1>(a), std::get<1>(b)) &&
+           DefaultHash<V>::Hash::Equal(std::get<2>(a), std::get<2>(b));
+  }
+  static const bool safe_to_compare_to_empty_or_deleted =
+      DefaultHash<T>::Hash::safe_to_compare_to_empty_or_deleted &&
+      DefaultHash<U>::Hash::safe_to_compare_to_empty_or_deleted &&
+      DefaultHash<V>::Hash::safe_to_compare_to_empty_or_deleted;
+};
+
+template <typename T, typename U, typename V>
+struct DefaultHash<std::tuple<T, U, V>> {
+  using Hash = TupleHash<T, U, V>;
+};
+
 }  // namespace WTF
 
 using WTF::DefaultHash;
 using WTF::IntHash;
 using WTF::PtrHash;
 
 #endif  // WTF_HashFunctions_h