Image decode color: Push color profile from browser to renderer

ui/gfx/color_profile_win.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_profile.h"
 
 #include <windows.h>
 #include <stddef.h>
 #include <map>
 
 #include "base/files/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/synchronization/lock.h"
 
 namespace gfx {
 
+namespace {
+
 class ColorProfileCache {
  public:
   // A thread-safe cache of color profiles keyed by windows device name.
   ColorProfileCache() {}
 
   bool Find(const std::wstring& device, std::vector<char>* profile) {
     base::AutoLock lock(lock_);
     DeviceColorProfile::const_iterator it = cache_.find(device);
     if (it == cache_.end())
       return false;
     *profile = it->second;
     return true;
   }
 
-  void Insert(const std::wstring& device, const std::vector<char>& profile) {
-    base::AutoLock lock(lock_);
-    cache_[device] = profile;
+  void Insert(const std::wstring& device) {
+    std::vector<char> profile;
+
+    {
+      base::AutoLock lock(lock_);
+      if (cache_.find(device) != cache_.end())
+        return;
+    }
+
+    HDC hdc = ::CreateDC(device.c_str(), NULL, NULL, NULL);
+    DWORD path_length = MAX_PATH;
+    WCHAR path[MAX_PATH + 1];
+    BOOL get_icm_result = ::GetICMProfile(hdc, &path_length, path);
+    ::DeleteDC(hdc);
+    if (get_icm_result) {
+      base::FilePath file_name = base::FilePath(path).BaseName();
+      // TODO(ccameron): This should skip reading sRGB color profiles, but
+      // pre-existing behavior is to read them, and the fix for that will

[Noel Gordon, 2016/06/01 06:08:25]

Looking at code-diff left at line 91, I see

if (file_name != base::FilePath(L"sRGB Color Space Profile.icm")) {

so the pre-existing behavior was to skip reading them.  An empty profile should
be stored / returned in that case. The Blink-side renderer code will interpolate
the sRGB color profile as a result, this to save us sending them to renderers
since the sRGB profile is the system default on win.

I will be OOO for the next few months, so perhaps fix the above, and have you
other reviewers check it to move on to submit.

+      // require rebaselining several layout tests.
+      std::string data;
+      if (base::ReadFileToString(base::FilePath(path), &data))
+        profile.assign(data.data(), data.data() + data.size());
+      size_t length = profile.size();
+      if (gfx::InvalidColorProfileLength(length))
+        profile.clear();
+    }
+
+    {
+      base::AutoLock lock(lock_);
+      cache_[device] = profile;
+    }
   }
 
   bool Erase(const std::wstring& device) {
     base::AutoLock lock(lock_);
     DeviceColorProfile::iterator it = cache_.find(device);
     if (it == cache_.end())
       return false;
     cache_.erase(device);
     return true;
   }
@@ skipping 12 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ColorProfileCache);
 };
 
 base::LazyInstance<ColorProfileCache>::Leaky g_color_profile_cache =
     LAZY_INSTANCE_INITIALIZER;
 
 inline ColorProfileCache& GetColorProfileCache() {
   return g_color_profile_cache.Get();
 }
 
+BOOL CALLBACK EnumMonitorCallback(HMONITOR monitor,
+                                  HDC hdc,
+                                  LPRECT rect,
+                                  LPARAM data) {
+
+  MONITORINFOEX monitor_info;
+  monitor_info.cbSize = sizeof(MONITORINFOEX);
+  if (::GetMonitorInfo(monitor, &monitor_info))
+    GetColorProfileCache().Insert(monitor_info.szDevice);
+  return TRUE;
+}
+
+}  // namespace
+
+void UpdateDisplayColorProfileCache() {
+  EnumDisplayMonitors(nullptr, nullptr, EnumMonitorCallback, 0);
+}
+
 bool GetDisplayColorProfile(const gfx::Rect& bounds,
                             std::vector<char>* profile) {
   DCHECK(profile->empty());
 
   RECT rect = bounds.ToRECT();
   HMONITOR handle = ::MonitorFromRect(&rect, MONITOR_DEFAULTTONULL);
   if (bounds.IsEmpty() || !handle)
     return false;
 
   MONITORINFOEX monitor;
   monitor.cbSize = sizeof(MONITORINFOEX);
-  CHECK(::GetMonitorInfo(handle, &monitor));
-  if (GetColorProfileCache().Find(monitor.szDevice, profile))
-    return true;
-
-  HDC hdc = ::CreateDC(monitor.szDevice, NULL, NULL, NULL);
-  DWORD path_length = MAX_PATH;
-  WCHAR path[MAX_PATH + 1];
-  BOOL result = ::GetICMProfile(hdc, &path_length, path);
-  ::DeleteDC(hdc);
-  if (!result)
-    return false;
-
-  base::FilePath file_name = base::FilePath(path).BaseName();
-  if (file_name != base::FilePath(L"sRGB Color Space Profile.icm")) {
-    std::string data;
-    if (base::ReadFileToString(base::FilePath(path), &data))
-      profile->assign(data.data(), data.data() + data.size());
-    size_t length = profile->size();
-    if (gfx::InvalidColorProfileLength(length))
-      profile->clear();
-  }
-
-  GetColorProfileCache().Insert(monitor.szDevice, *profile);
-  return true;
+  if (::GetMonitorInfo(handle, &monitor))
+    return GetColorProfileCache().Find(monitor.szDevice, profile);
+  return false;
 }
 
 void ReadColorProfile(std::vector<char>* profile) {
-  // TODO: support multiple monitors.
-  HDC screen_dc = GetDC(NULL);
-  DWORD path_len = MAX_PATH;
-  WCHAR path[MAX_PATH + 1];
+  // TODO: This function should be named to reflect that it is querying the
+  // primary monitor.
+  POINT point = {0, 0};
+  HMONITOR handle = ::MonitorFromPoint(point, MONITOR_DEFAULTTOPRIMARY);
+  if (!handle)
+    return;
 
-  BOOL result = GetICMProfile(screen_dc, &path_len, path);
-  ReleaseDC(NULL, screen_dc);
-  if (!result)
-    return;
-  std::string profileData;
-  if (!base::ReadFileToString(base::FilePath(path), &profileData))
-    return;
-  size_t length = profileData.size();
-  if (gfx::InvalidColorProfileLength(length))
-    return;
-  profile->assign(profileData.data(), profileData.data() + length);
+  MONITORINFOEX monitor;
+  monitor.cbSize = sizeof(MONITORINFOEX);
+  if (::GetMonitorInfo(handle, &monitor))
+    GetColorProfileCache().Find(monitor.szDevice, profile);
 }
 
 }  // namespace gfx