Color: Separate ICCProfile and ColorSpace structures

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 "base/lazy_instance.h"
 #include "base/synchronization/lock.h"
+#include "ui/gfx/icc_profile.h"
 
 namespace gfx {
 
-namespace {
-static const size_t kMinProfileLength = 128;
-static const size_t kMaxProfileLength = 4 * 1024 * 1024;
-}  // namespace
+ColorSpace::ColorSpace() = default;
 
-// The structure used to look up GlobalData structures.
-struct ColorSpace::Key {
-  Key(ColorSpace::Type type, const std::vector<char>& icc_profile)
-      : type(type), icc_profile(icc_profile) {}
-
-  bool operator<(const Key& other) const {
-    if (type < other.type)
-      return true;
-    if (type > other.type)
-      return false;
-    if (type != Type::ICC_PROFILE)
-      return false;
-
-    if (icc_profile.size() < other.icc_profile.size())
-      return true;
-    if (icc_profile.size() > other.icc_profile.size())
-      return false;
-    for (size_t i = 0; i < icc_profile.size(); ++i) {
-      if (icc_profile[i] < other.icc_profile[i])
-        return true;
-      if (icc_profile[i] > other.icc_profile[i])
-        return false;
-    }
-    return false;
-  }
-
-  ColorSpace::Type type;
-  const std::vector<char> icc_profile;
-};
-
-// Because this structure is shared across gfx::ColorSpace objects on
-// different threads, it needs to be thread-safe.
-class ColorSpace::GlobalData
-    : public base::RefCountedThreadSafe<ColorSpace::GlobalData> {
- public:
-  static void Get(const Key& key, scoped_refptr<GlobalData>* value) {
-    base::AutoLock lock(map_lock_.Get());
-    auto insert_result = map_.Get().insert(std::make_pair(key, nullptr));
-    if (insert_result.second)
-      insert_result.first->second = new GlobalData(key, insert_result.first);
-    *value = make_scoped_refptr(insert_result.first->second);
-  }
-
-  const std::vector<char>& GetICCProfile() const { return icc_profile_; }
-
- private:
-  friend class base::RefCountedThreadSafe<GlobalData>;
-
-  GlobalData(const Key& key, std::map<Key, GlobalData*>::iterator iterator)
-      : iterator_(iterator) {
-    // TODO: Compute the ICC profile for named color spaces.
-    if (key.type == Type::ICC_PROFILE)
-      icc_profile_ = key.icc_profile;
-  }
-  ~GlobalData() {
-    base::AutoLock lock(map_lock_.Get());
-    map_.Get().erase(iterator_);
-  }
-
-  std::vector<char> icc_profile_;
-
-  // In order to remove |this| from |map_| when its last reference goes away,
-  // keep in |iterator_| the corresponding iterator in |map_|.
-  std::map<Key, GlobalData*>::iterator iterator_;
-  // The |map_| tracks the existing GlobalData instances, which are owned by
-  // ColorSpace instances. Note that |map_| must be leaky because GlobalData
-  // instances will reach back into it at unpredictable times during tear-down.
-  static base::LazyInstance<std::map<Key, GlobalData*>>::Leaky map_;
-  static base::LazyInstance<base::Lock>::Leaky map_lock_;
-};
-
-base::LazyInstance<std::map<ColorSpace::Key, ColorSpace::GlobalData*>>::Leaky
-    ColorSpace::GlobalData::map_ = LAZY_INSTANCE_INITIALIZER;
-base::LazyInstance<base::Lock>::Leaky
-    ColorSpace::GlobalData::map_lock_ = LAZY_INSTANCE_INITIALIZER;
-
-ColorSpace::ColorSpace() = default;
-ColorSpace::ColorSpace(ColorSpace&& other) = default;
-ColorSpace::ColorSpace(const ColorSpace& other) = default;
-ColorSpace& ColorSpace::operator=(const ColorSpace& other) = default;
-ColorSpace::~ColorSpace() = default;
-
-bool ColorSpace::operator==(const ColorSpace& other) const {
-  if (type_ == Type::ICC_PROFILE && other.type_ == Type::ICC_PROFILE)
-    return global_data_ == other.global_data_;
-  return type_ == other.type_;
-}
-
-bool ColorSpace::operator<(const ColorSpace& other) const {
-  // Note that this does a pointer-based comparision.
-  if (type_ == Type::ICC_PROFILE && other.type_ == Type::ICC_PROFILE)
-    return global_data_.get() < other.global_data_.get();
-  return type_ < other.type_;
+// static
+ColorSpace ColorSpace::CreateSRGB() {
+  ColorSpace color_space;
+  color_space.valid_ = true;
+  color_space.icc_profile_id_ = ICCProfile::kSRGBId;
+  return color_space;
 }
 
 // static
-ColorSpace ColorSpace::FromICCProfile(const std::vector<char>& icc_profile) {
+ColorSpace ColorSpace::CreateJpeg() {
   ColorSpace color_space;
-  if (IsValidProfileLength(icc_profile.size())) {
-    color_space.type_ = Type::ICC_PROFILE;
-    Key key(Type::ICC_PROFILE, icc_profile);
-    GlobalData::Get(key, &color_space.global_data_);
-  }
+  color_space.valid_ = true;
+  color_space.icc_profile_id_ = ICCProfile::kJpegId;
   return color_space;
 }
 
-#if !defined(OS_WIN) && !defined(OS_MACOSX)
 // static
-ColorSpace ColorSpace::FromBestMonitor() {
-  return ColorSpace();
-}
-#endif
-
-const std::vector<char>& ColorSpace::GetICCProfile() const {
-  if (!global_data_) {
-    Key key(type_, std::vector<char>());
-    GlobalData::Get(key, &global_data_);
-  }
-  return global_data_->GetICCProfile();
+ColorSpace ColorSpace::CreateREC601() {
+  ColorSpace color_space;
+  color_space.valid_ = true;
+  color_space.icc_profile_id_ = ICCProfile::kRec601Id;
+  return color_space;
 }
 
 // static
-bool ColorSpace::IsValidProfileLength(size_t length) {
-  return length >= kMinProfileLength && length <= kMaxProfileLength;
+ColorSpace ColorSpace::CreateREC709() {
+  ColorSpace color_space;
+  color_space.valid_ = true;
+  color_space.icc_profile_id_ = ICCProfile::kRec709Id;
+  return color_space;
+}
+
+bool ColorSpace::operator==(const ColorSpace& other) const {
+  // TODO(ccameron): The |icc_profile_id_| should eventually not factor in
+  // to equality comparison at all, because it's just an optimization, but
+  // for now there is no other data in this structure.
+  return valid_ == other.valid_ && icc_profile_id_ == other.icc_profile_id_;
 }
 
 }  // namespace gfx