Respect colorSpace in DecodingImageGenerator::onGetPixels()

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

 /*
  * Copyright (C) 2005, 2006, 2007, 2008, 2011, 2012 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,
@@ skipping 321 matching lines @@
   }
   static bool IsDeletedValue(const TraitType& value) {
     return FirstTraits::IsDeletedValue(value.first);
   }
 };
 
 template <typename First, typename Second>
 struct HashTraits<std::pair<First, Second>>
     : public PairHashTraits<HashTraits<First>, HashTraits<Second>> {};
 
+template <typename FirstTraitsArg,
+          typename SecondTraitsArg,
+          typename ThirdTraitsArg>
+struct TupleHashTraits
+    : GenericHashTraits<std::tuple<typename FirstTraitsArg::TraitType,
+                                   typename SecondTraitsArg::TraitType,
+                                   typename ThirdTraitsArg::TraitType>> {
+  typedef FirstTraitsArg FirstTraits;
+  typedef SecondTraitsArg SecondTraits;
+  typedef ThirdTraitsArg ThirdTraits;
+  typedef std::tuple<typename FirstTraits::TraitType,
+                     typename SecondTraits::TraitType,
+                     typename ThirdTraits::TraitType>
+      TraitType;
+  typedef std::tuple<typename FirstTraits::EmptyValueType,
+                     typename SecondTraits::EmptyValueType,
+                     typename ThirdTraits::EmptyValueType>
+      EmptyValueType;
+
+  static const bool kEmptyValueIsZero = FirstTraits::kEmptyValueIsZero &&
+                                        SecondTraits::kEmptyValueIsZero &&
+                                        ThirdTraits::kEmptyValueIsZero;
+  static EmptyValueType EmptyValue() {
+    return std::make_tuple(FirstTraits::EmptyValue(),
+                           SecondTraits::EmptyValue(),
+                           ThirdTraits::EmptyValue());
+  }
+
+  static const bool kHasIsEmptyValueFunction =
+      FirstTraits::kHasIsEmptyValueFunction ||
+      SecondTraits::kHasIsEmptyValueFunction ||
+      ThirdTraits::kHasIsEmptyValueFunction;
+  static bool IsEmptyValue(const TraitType& value) {
+    return IsHashTraitsEmptyValue<FirstTraits>(std::get<0>(value)) &&
+           IsHashTraitsEmptyValue<SecondTraits>(std::get<1>(value)) &&
+           IsHashTraitsEmptyValue<ThirdTraits>(std::get<2>(value));
+  }
+
+  static const unsigned kMinimumTableSize = FirstTraits::kMinimumTableSize;
+
+  static void ConstructDeletedValue(TraitType& slot, bool zero_value) {
+    FirstTraits::ConstructDeletedValue(std::get<0>(slot), zero_value);
+    // For GC collections the memory for the backing is zeroed when it is
+    // allocated, and the constructors may take advantage of that,
+    // especially if a GC occurs during insertion of an entry into the
+    // table. This slot is being marked deleted, but If the slot is reused
+    // at a later point, the same assumptions around memory zeroing must
+    // hold as they did at the initial allocation.  Therefore we zero the
+    // value part of the slot here for GC collections.
+    if (zero_value) {
+      memset(reinterpret_cast<void*>(&std::get<1>(slot)), 0,
+             sizeof(std::get<1>(slot)));
+      memset(reinterpret_cast<void*>(&std::get<2>(slot)), 0,
+             sizeof(std::get<2>(slot)));
+    }
+  }
+  static bool IsDeletedValue(const TraitType& value) {
+    return FirstTraits::IsDeletedValue(std::get<0>(value));
+  }
+};
+
+template <typename First, typename Second, typename Third>
+struct HashTraits<std::tuple<First, Second, Third>>
+    : public TupleHashTraits<HashTraits<First>,
+                             HashTraits<Second>,
+                             HashTraits<Third>> {};
+
 template <typename KeyTypeArg, typename ValueTypeArg>
 struct KeyValuePair {
   typedef KeyTypeArg KeyType;
 
   template <typename IncomingKeyType, typename IncomingValueType>
   KeyValuePair(IncomingKeyType&& key, IncomingValueType&& value)
       : key(std::forward<IncomingKeyType>(key)),
         value(std::forward<IncomingValueType>(value)) {}
 
   template <typename OtherKeyType, typename OtherValueType>
@@ skipping 64 matching lines @@
 template <typename T>
 struct NullableHashTraits : public HashTraits<T> {
   static const bool kEmptyValueIsZero = false;
   static T EmptyValue() { return reinterpret_cast<T>(1); }
 };
 
 }  // namespace WTF
 
 using WTF::HashTraits;
 using WTF::PairHashTraits;
+using WTF::TupleHashTraits;
 using WTF::NullableHashTraits;
 using WTF::SimpleClassHashTraits;
 
 #endif  // WTF_HashTraits_h