Use real colorspace for DirectComposition overlays.

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"
@@ skipping 600 matching lines @@
     case ColorSpace::TransferID::SMPTEST2084:
     case ColorSpace::TransferID::SMPTEST2084_NON_HDR:
     case ColorSpace::TransferID::INVALID:
     case ColorSpace::TransferID::ICC_BASED:
       break;
   }
 
   return false;
 }
 
+bool ColorSpace::Serialize(base::Pickle* pickle) const {
+  if (!pickle->WriteUInt32(static_cast<uint32_t>(primaries_)) ||
+      !pickle->WriteUInt32(static_cast<uint32_t>(transfer_)) ||
+      !pickle->WriteUInt32(static_cast<uint32_t>(matrix_)) ||
+      !pickle->WriteUInt32(static_cast<uint32_t>(range_)) ||
+      !pickle->WriteUInt64(icc_profile_id_))
+    return false;
+  if (primaries_ == PrimaryID::CUSTOM &&
+      !pickle->WriteBytes(reinterpret_cast<const char*>(custom_primary_matrix_),
+                          sizeof(custom_primary_matrix_)))
+    return false;
+  if (transfer_ == TransferID::CUSTOM &&
+      !pickle->WriteBytes(
+          reinterpret_cast<const char*>(custom_transfer_params_),
+          sizeof(custom_transfer_params_)))
+    return false;
+  return true;
+}
+
+template <typename T>
+static bool ReadValue(base::PickleIterator* iter, T* result) {
+  uint32_t value;
+  if (!iter->ReadUInt32(&value))
+    return false;
+  *result = static_cast<T>(value);
+  if (*result > T::LAST)
+    return false;
+  return true;
+}
+
+bool ColorSpace::ReadFromPickle(base::PickleIterator* iter) {
+  if (!ReadValue(iter, &primaries_))
+    return false;
+  if (!ReadValue(iter, &transfer_))
+    return false;
+  if (!ReadValue(iter, &matrix_))
+    return false;
+  if (!ReadValue(iter, &range_))
+    return false;
+  if (!iter->ReadUInt64(&icc_profile_id_))
+    return false;
+
+  if (primaries_ == PrimaryID::CUSTOM) {
+    const char* data = nullptr;
+    if (!iter->ReadBytes(&data, sizeof(custom_primary_matrix_)))
+      return false;
+    memcpy(custom_primary_matrix_, data, sizeof(custom_primary_matrix_));
+  }
+  if (transfer_ == TransferID::CUSTOM) {
+    const char* data = nullptr;
+    if (!iter->ReadBytes(&data, sizeof(custom_transfer_params_)))
+      return false;
+    memcpy(custom_transfer_params_, data, sizeof(custom_transfer_params_));
+  }
+
+  return true;
+}
+
 bool ColorSpace::GetInverseTransferFunction(SkColorSpaceTransferFn* fn) const {
   if (!GetTransferFunction(fn))
     return false;
   *fn = SkTransferFnInverse(*fn);
   return true;
 }
 
 bool ColorSpace::HasExtendedSkTransferFn() const {
   return transfer_ == TransferID::LINEAR_HDR ||
          transfer_ == TransferID::IEC61966_2_1_HDR;
@@ skipping 116 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