Fix id tracking bug in ICCProfile

ui/gfx/icc_profile.cc

 // Copyright 2016 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/icc_profile.h"
 
 #include <list>
 
 #include "base/containers/mru_cache.h"
 #include "base/lazy_instance.h"
 #include "base/synchronization/lock.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkICC.h"
 #include "ui/gfx/color_transform.h"
 
 namespace gfx {
 
+const uint64_t ICCProfile::test_id_adobe_rgb_ = 1;
+const uint64_t ICCProfile::test_id_color_spin_ = 2;
+const uint64_t ICCProfile::test_id_generic_rgb_ = 3;
+const uint64_t ICCProfile::test_id_srgb_ = 4;
+
 namespace {
 const size_t kMinProfileLength = 128;
 const size_t kMaxProfileLength = 4 * 1024 * 1024;
 
 // Allow keeping around a maximum of 8 cached ICC profiles. Beware that
 // we will do a linear search thorugh currently-cached ICC profiles,
 // when creating a new ICC profile.
 const size_t kMaxCachedICCProfiles = 8;
 
 struct Cache {
   Cache() : id_to_icc_profile_mru(kMaxCachedICCProfiles) {}
   ~Cache() {}
 
-  // Start from-ICC-data IDs at the end of the hard-coded list.
+  // Start from-ICC-data IDs at the end of the hard-coded test id list above.
   uint64_t next_unused_id = 5;
   base::MRUCache<uint64_t, ICCProfile> id_to_icc_profile_mru;
   base::Lock lock;
 };
 static base::LazyInstance<Cache> g_cache;
 
 }  // namespace
 
 ICCProfile::ICCProfile() = default;
 ICCProfile::ICCProfile(ICCProfile&& other) = default;
 ICCProfile::ICCProfile(const ICCProfile& other) = default;
 ICCProfile& ICCProfile::operator=(ICCProfile&& other) = default;
 ICCProfile& ICCProfile::operator=(const ICCProfile& other) = default;
 ICCProfile::~ICCProfile() = default;
 
 bool ICCProfile::operator==(const ICCProfile& other) const {
   return data_ == other.data_;
 }
 
 bool ICCProfile::operator!=(const ICCProfile& other) const {
   return !(*this == other);
 }
 
 // static
 ICCProfile ICCProfile::FromData(const void* data, size_t size) {
+  return FromDataWithId(data, size, 0);
+}
+
+// static
+ICCProfile ICCProfile::FromDataWithId(const void* data,
+                                      size_t size,
+                                      uint64_t new_profile_id) {
   if (!IsValidProfileLength(size)) {
     if (size != 0)
       DLOG(ERROR) << "Invalid ICC profile length: " << size << ".";
     return ICCProfile();
   }
 
-  uint64_t new_profile_id = 0;
   const char* data_as_char = reinterpret_cast<const char*>(data);
   {
     // Linearly search the cached ICC profiles to find one with the same data.
     // If it exists, re-use its id and touch it in the cache.
     Cache& cache = g_cache.Get();
     base::AutoLock lock(cache.lock);
     for (auto iter = cache.id_to_icc_profile_mru.begin();
          iter != cache.id_to_icc_profile_mru.end(); ++iter) {
       const std::vector<char>& iter_data = iter->second.data_;
       if (iter_data.size() != size || memcmp(data, iter_data.data(), size))
         continue;
       auto found = cache.id_to_icc_profile_mru.Get(iter->second.id_);
       return found->second;
     }
-    new_profile_id = cache.next_unused_id++;
+    if (!new_profile_id)
+      new_profile_id = cache.next_unused_id++;
   }
 
   // Create a new cached id and add it to the cache.
   ICCProfile icc_profile;
   icc_profile.id_ = new_profile_id;
   icc_profile.data_.insert(icc_profile.data_.begin(), data_as_char,
                            data_as_char + size);
   icc_profile.ComputeColorSpaceAndCache();
   return icc_profile;
 }
@@ skipping 152 matching lines @@
     cache.id_to_icc_profile_mru.Put(id_, *this);
   }
 }
 
 // static
 bool ICCProfile::IsValidProfileLength(size_t length) {
   return length >= kMinProfileLength && length <= kMaxProfileLength;
 }
 
 }  // namespace gfx