Have Chrome draw top window border when using custom titlebar.

chrome/browser/themes/theme_service_win.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 "chrome/browser/themes/theme_service_win.h"
 
 #include "base/bind.h"
 #include "base/win/windows_version.h"
 #include "chrome/browser/themes/theme_properties.h"
 #include "chrome/grit/theme_resources.h"
 #include "skia/ext/skia_utils_win.h"
 #include "ui/base/win/shell.h"
+#include "ui/gfx/color_utils.h"
 
 ThemeServiceWin::ThemeServiceWin() {
   // This just checks for Windows 10 instead of calling ShouldUseDwmFrameColor()
   // because we want to monitor the frame color even when a custom frame is in
   // use, so that it will be correct if at any time the user switches to the
   // native frame.
   if (base::win::GetVersion() >= base::win::VERSION_WIN10) {
     dwm_key_.reset(new base::win::RegKey(
         HKEY_CURRENT_USER, L"SOFTWARE\\Microsoft\\Windows\\DWM", KEY_READ));
     if (dwm_key_->Valid())
       OnDwmKeyUpdated();
     else
       dwm_key_.reset();
   }
 }
 
 ThemeServiceWin::~ThemeServiceWin() {
 }
 
 bool ThemeServiceWin::ShouldUseNativeFrame() const {
   return !HasCustomImage(IDR_THEME_FRAME) && ui::win::IsAeroGlassEnabled();
 }
 
 SkColor ThemeServiceWin::GetDefaultColor(int id, bool incognito) const {
   if (ShouldUseDwmFrameColor()) {
     // Active native windows on Windows 10 may have a custom frame color.
     if (id == ThemeProperties::COLOR_FRAME)
       return dwm_frame_color_;
 
+    if (id == ThemeProperties::COLOR_ACCENT_BORDER)
+      return dwm_accent_border_color_;
+
     // Inactive native windows on Windows 10 always have a white frame.
     if (id == ThemeProperties::COLOR_FRAME_INACTIVE)
         return SK_ColorWHITE;
   }
 
   return ThemeService::GetDefaultColor(id, incognito);
 }
 
 bool ThemeServiceWin::ShouldUseDwmFrameColor() const {
   return ShouldUseNativeFrame() &&
          (base::win::GetVersion() >= base::win::VERSION_WIN10);
 }
 
 void ThemeServiceWin::OnDwmKeyUpdated() {
   // Attempt to read the accent color.
   DWORD accent_color, color_prevalence;
   dwm_frame_color_ =
       ((dwm_key_->ReadValueDW(L"ColorPrevalence", &color_prevalence) ==
         ERROR_SUCCESS) &&
        (color_prevalence == 1) &&
        (dwm_key_->ReadValueDW(L"AccentColor", &accent_color) == ERROR_SUCCESS))
           ? skia::COLORREFToSkColor(accent_color)
           : SK_ColorWHITE;
 
+  dwm_accent_border_color_ = SK_ColorWHITE;
+  DWORD colorization_color, colorization_color_balance;
+  if ((dwm_key_->ReadValueDW(L"ColorizationColor", &colorization_color) ==

[Peter Kasting, 2016/10/11 21:09:34]

Does calling DwmGetColorizationColor() get this value?

You could probably get both these values with DwmGetColorizationParameters()
(see http://www.codeproject.com/Articles/610909/Changing-Windows-Aero-Color on
how to use this undocumented API), but that may be more trouble than it's worth.

+       ERROR_SUCCESS) &&
+      (dwm_key_->ReadValueDW(L"ColorizationColorBalance",
+                             &colorization_color_balance) == ERROR_SUCCESS)) {
+    // The accent border color is a linear blend between the colorization
+    // color and the neutral #d9d9d9. colorization_color_balance is the
+    // percentage of the colorization color in that blend.
+    //
+    // On Windows version 1611 colorization_color_balance can be 0xfffffff3 if
+    // the accent color is taken from the background and either the background
+    // is a solid color or was just changed to a slideshow. It's unclear what
+    // that value's supposed to mean, so change it to 80 to match Edge's
+    // behavior.
+    if (colorization_color_balance > 100)
+      colorization_color_balance = 80;
+
+    // colorization_color's high byte can be 0xc4 or 0, so replace it with
+    // an 0xff alpha to make an opaque color.

[Peter Kasting, 2016/10/11 20:01:38]

Nit: I would be clearer about the meaning of this byte, e.g.:

|colorization_color|'s high byte is not an alpha value but a channel order code,
so replace it with 0xff to make this an opaque ARGB color.

(Bret, we don't need to check for 0x00 and byteswap BGR -> RGB, do we?)

[Bret, 2016/10/11 20:48:19]

Oh oops! You're right, this could be wrong if the color is in BGR order.
ColorizationColor is always in RGB format in practice unless someone mucks with
the registry, but it's more correct to use the helper that accent_color uses
above, skia::COLORREFToSkColor, which uses Windows macros. Then this whole
comment can go away.

[Peter Kasting, 2016/10/11 20:56:51]

Hmm, that function looks like it assumes 0BGR instead of looking at the high
byte.

Maybe we need to use that function and add a high byte check?  I see about 4
callsites of this currently, so hopefully auditing these to be sure that was the
right thing to do wouldn't be onerous.

[Bret, 2016/10/11 21:10:15]

Oh I misread the definition of COLORREFToSkColor. The first branch in the
preprocessor switch looks correct to me, it's using the Get[RGB]Value macros,
which are provided by Windows and should always do the right thing. So maybe
we're actually getting the second branch? It's not a huge deal in either case,
it'd just be nice to be correct if someone manually edits the registry to be
0BGR order lol.

[Peter Kasting, 2016/10/11 21:26:26]

As noted in my reply to jbauman, I think this is always 0x??RRGGBB, and the top
byte is not a channel order indicator.  It's not a COLORREF stuffed into a reg
key.  So I think the existing code here is good.

+    SkColor input_color = SkColorSetA(colorization_color, 0xff);
+
+    dwm_accent_border_color_ =
+        color_utils::AlphaBlend(input_color, SkColorSetRGB(0xd9, 0xd9, 0xd9),
+                                255 * colorization_color_balance / 100.f);

[Peter Kasting, 2016/10/11 20:01:38]

This implicitly truncates float to int.  Do one of these (they should be
equivalent):

gfx::ToRoundedInt(255 * colorization_color_balance / 100.f)
Tween::LinearIntValueBetween(colorization_color_balance / 100., 0, 255);

+  }
+
   // Watch for future changes.
   if (!dwm_key_->StartWatching(base::Bind(
           &ThemeServiceWin::OnDwmKeyUpdated, base::Unretained(this))))
     dwm_key_.reset();
 }