Initial skeleton of high-contrast mode.

third_party/WebKit/Source/platform/graphics/GraphicsContext.cpp

 /*
  * Copyright (C) 2003, 2004, 2005, 2006, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 29 matching lines @@
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/wtf/Assertions.h"
 #include "platform/wtf/MathExtras.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/core/SkAnnotation.h"
 #include "third_party/skia/include/core/SkColorFilter.h"
 #include "third_party/skia/include/core/SkData.h"
 #include "third_party/skia/include/core/SkRRect.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
+#include "third_party/skia/include/effects/SkHighContrastFilter.h"
 #include "third_party/skia/include/effects/SkLumaColorFilter.h"
 #include "third_party/skia/include/effects/SkPictureImageFilter.h"
+#include "third_party/skia/include/effects/SkTableColorFilter.h"
 #include "third_party/skia/include/pathops/SkPathOps.h"
 #include "third_party/skia/include/utils/SkNullCanvas.h"
 
 namespace blink {
 
-GraphicsContext::GraphicsContext(PaintController& paint_controller,
-                                 DisabledMode disable_context_or_painting,
-                                 SkMetaData* meta_data)
+GraphicsContext::GraphicsContext(
+    PaintController& paint_controller,
+    const HighContrastSettings* high_contrast_settings,
+    DisabledMode disable_context_or_painting,
+    SkMetaData* meta_data)
     : canvas_(nullptr),
       paint_controller_(paint_controller),
       paint_state_stack_(),
       paint_state_index_(0),
 #if DCHECK_IS_ON()
       layer_count_(0),
       disable_destruction_checks_(false),
       in_drawing_recorder_(false),
 #endif
       disabled_state_(disable_context_or_painting),
       device_scale_factor_(1.0f),
       printing_(false),
       has_meta_data_(!!meta_data) {
   if (meta_data)
     meta_data_ = *meta_data;
 
   // FIXME: Do some tests to determine how many states are typically used, and
   // allocate several here.
   paint_state_stack_.push_back(GraphicsContextState::Create());
   paint_state_ = paint_state_stack_.back().get();
 
   if (ContextDisabled()) {
     DEFINE_STATIC_LOCAL(SkCanvas*, null_sk_canvas,
                         (SkMakeNullCanvas().release()));
     DEFINE_STATIC_LOCAL(SkiaPaintCanvas, null_canvas, (null_sk_canvas));
     canvas_ = &null_canvas;
   }
+
+  if (high_contrast_settings) {
+    high_contrast_settings_ = *high_contrast_settings;
+    UpdateHighContrastFilterFromSettings();
+  }
 }
 
 GraphicsContext::~GraphicsContext() {
 #if DCHECK_IS_ON()
   if (!disable_destruction_checks_) {
     DCHECK(!paint_state_index_);
     DCHECK(!paint_state_->SaveCount());
     DCHECK(!layer_count_);
     DCHECK(!SaveCount());
   }
@@ skipping 36 matching lines @@
   // (on top of its own saveCount), except for the first frame.
   unsigned count = paint_state_index_;
   DCHECK_GE(paint_state_stack_.size(), paint_state_index_);
   for (unsigned i = 0; i <= paint_state_index_; ++i)
     count += paint_state_stack_[i]->SaveCount();
 
   return count;
 }
 #endif
 
+void GraphicsContext::SetHighContrast(const HighContrastSettings& settings) {
+  high_contrast_settings_ = settings;
+  UpdateHighContrastFilterFromSettings();
+}
+
 void GraphicsContext::SaveLayer(const SkRect* bounds, const PaintFlags* flags) {
   if (ContextDisabled())
     return;
 
   DCHECK(canvas_);
   canvas_->saveLayer(bounds, flags);
 }
 
 void GraphicsContext::RestoreLayer() {
   if (ContextDisabled())
@@ skipping 191 matching lines @@
 int GraphicsContext::FocusRingOutsetExtent(int offset, int width) {
   // Unlike normal outlines (whole width is outside of the offset), focus
   // rings are drawn with the center of the path aligned with the offset, so
   // only half of the width is outside of the offset.
   return AdjustedFocusRingOffset(offset) + (width + 1) / 2;
 }
 
 void GraphicsContext::DrawFocusRingPath(const SkPath& path,
                                         const Color& color,
                                         float width) {
-  DrawPlatformFocusRing(path, canvas_, color.Rgb(), width);
+  DrawPlatformFocusRing(path, canvas_, ApplyHighContrastFilter(color).Rgb(),
+                        width);
 }
 
 void GraphicsContext::DrawFocusRingRect(const SkRect& rect,
                                         const Color& color,
                                         float width) {
-  DrawPlatformFocusRing(rect, canvas_, color.Rgb(), width);
+  DrawPlatformFocusRing(rect, canvas_, ApplyHighContrastFilter(color).Rgb(),
+                        width);
 }
 
 void GraphicsContext::DrawFocusRing(const Path& focus_ring_path,
                                     float width,
                                     int offset,
                                     const Color& color) {
   // FIXME: Implement support for offset.
   if (ContextDisabled())
     return;
 
@@ skipping 45 matching lines @@
 
   if (shadow_spread < 0)
     bounds.Inflate(-shadow_spread);
 
   FloatRect offset_bounds = bounds;
   offset_bounds.Move(-shadow_offset);
   return UnionRect(bounds, offset_bounds);
 }
 
 void GraphicsContext::DrawInnerShadow(const FloatRoundedRect& rect,
-                                      const Color& shadow_color,
+                                      const Color& orig_shadow_color,
                                       const FloatSize& shadow_offset,
                                       float shadow_blur,
                                       float shadow_spread,
                                       Edges clipped_edges) {
   if (ContextDisabled())
     return;
 
+  Color shadow_color = ApplyHighContrastFilter(orig_shadow_color);
+
   FloatRect hole_rect(rect.Rect());
   hole_rect.Inflate(-shadow_spread);
 
   if (hole_rect.IsEmpty()) {
     FillRoundedRect(rect, shadow_color);
     return;
   }
 
   if (clipped_edges & kLeftEdge) {
     hole_rect.Move(-std::max(shadow_offset.Width(), 0.0f) - shadow_blur, 0);
@@ skipping 86 matching lines @@
     if (is_vertical_line) {
       p1.SetY(p1.Y() + width / 2.f);
       p2.SetY(p2.Y() - width / 2.f);
     } else {
       p1.SetX(p1.X() + width / 2.f);
       p2.SetX(p2.X() - width / 2.f);
     }
   }
 
   AdjustLineToPixelBoundaries(p1, p2, width, pen_style);
-  canvas_->drawLine(p1.X(), p1.Y(), p2.X(), p2.Y(), flags);
+  canvas_->drawLine(p1.X(), p1.Y(), p2.X(), p2.Y(),
+                    ApplyHighContrastFilter(&flags));
 }
 
 void GraphicsContext::DrawLineForText(const FloatPoint& pt, float width) {
   if (ContextDisabled())
     return;
 
   if (width <= 0)
     return;
 
   PaintFlags flags;
@@ skipping 56 matching lines @@
 }
 
 template <typename TextPaintInfo>
 void GraphicsContext::DrawTextInternal(const Font& font,
                                        const TextPaintInfo& text_info,
                                        const FloatPoint& point,
                                        const PaintFlags& flags) {
   if (ContextDisabled())
     return;
 
-  if (font.DrawText(canvas_, text_info, point, device_scale_factor_, flags))
+  if (font.DrawText(canvas_, text_info, point, device_scale_factor_,
+                    ApplyHighContrastFilter(&flags))) {
     paint_controller_.SetTextPainted();
+  }
 }
 
 void GraphicsContext::DrawText(const Font& font,
                                const TextRunPaintInfo& text_info,
                                const FloatPoint& point,
                                const PaintFlags& flags) {
   DrawTextInternal(font, text_info, point, flags);
 }
 
 void GraphicsContext::DrawText(const Font& font,
@@ skipping 23 matching lines @@
 }
 
 template <typename TextPaintInfo>
 void GraphicsContext::DrawTextInternal(const Font& font,
                                        const TextPaintInfo& text_info,
                                        const FloatPoint& point) {
   if (ContextDisabled())
     return;
 
   DrawTextPasses([&font, &text_info, &point, this](const PaintFlags& flags) {
-    if (font.DrawText(canvas_, text_info, point, device_scale_factor_, flags))
+    if (font.DrawText(canvas_, text_info, point, device_scale_factor_,
+                      ApplyHighContrastFilter(&flags)))
       paint_controller_.SetTextPainted();
   });
 }
 
 void GraphicsContext::DrawText(const Font& font,
                                const TextRunPaintInfo& text_info,
                                const FloatPoint& point) {
   DrawTextInternal(font, text_info, point);
 }
 
 void GraphicsContext::DrawText(const Font& font,
                                const TextFragmentPaintInfo& text_info,
                                const FloatPoint& point) {
   DrawTextInternal(font, text_info, point);
 }
 
 template <typename TextPaintInfo>
 void GraphicsContext::DrawEmphasisMarksInternal(const Font& font,
                                                 const TextPaintInfo& text_info,
                                                 const AtomicString& mark,
                                                 const FloatPoint& point) {
   if (ContextDisabled())
     return;
 
   DrawTextPasses(
       [&font, &text_info, &mark, &point, this](const PaintFlags& flags) {
         font.DrawEmphasisMarks(canvas_, text_info, mark, point,
-                               device_scale_factor_, flags);
+                               device_scale_factor_,
+                               ApplyHighContrastFilter(&flags));
       });
 }
 
 void GraphicsContext::DrawEmphasisMarks(const Font& font,
                                         const TextRunPaintInfo& text_info,
                                         const AtomicString& mark,
                                         const FloatPoint& point) {
   DrawEmphasisMarksInternal(font, text_info, mark, point);
 }
 
 void GraphicsContext::DrawEmphasisMarks(const Font& font,
                                         const TextFragmentPaintInfo& text_info,
                                         const AtomicString& mark,
                                         const FloatPoint& point) {
   DrawEmphasisMarksInternal(font, text_info, mark, point);
 }
 
 void GraphicsContext::DrawBidiText(
     const Font& font,
     const TextRunPaintInfo& run_info,
     const FloatPoint& point,
     Font::CustomFontNotReadyAction custom_font_not_ready_action) {
   if (ContextDisabled())
     return;
 
   DrawTextPasses([&font, &run_info, &point, custom_font_not_ready_action,
                   this](const PaintFlags& flags) {
     if (font.DrawBidiText(canvas_, run_info, point,
                           custom_font_not_ready_action, device_scale_factor_,
-                          flags))
+                          ApplyHighContrastFilter(&flags)))
       paint_controller_.SetTextPainted();
   });
 }
 
 void GraphicsContext::DrawHighlightForText(const Font& font,
                                            const TextRun& run,
                                            const FloatPoint& point,
                                            int h,
                                            const Color& background_color,
                                            int from,
@@ skipping 133 matching lines @@
   image->DrawTiledBorder(*this, dest, src_rect, tile_scale_factor, h_rule,
                          v_rule, op);
   paint_controller_.SetImagePainted();
 }
 
 void GraphicsContext::DrawOval(const SkRect& oval, const PaintFlags& flags) {
   if (ContextDisabled())
     return;
   DCHECK(canvas_);
 
-  canvas_->drawOval(oval, flags);
+  canvas_->drawOval(oval, ApplyHighContrastFilter(&flags));
 }
 
 void GraphicsContext::DrawPath(const SkPath& path, const PaintFlags& flags) {
   if (ContextDisabled())
     return;
   DCHECK(canvas_);
 
-  canvas_->drawPath(path, flags);
+  canvas_->drawPath(path, ApplyHighContrastFilter(&flags));
 }
 
 void GraphicsContext::DrawRect(const SkRect& rect, const PaintFlags& flags) {
   if (ContextDisabled())
     return;
   DCHECK(canvas_);
 
-  canvas_->drawRect(rect, flags);
+  canvas_->drawRect(rect, ApplyHighContrastFilter(&flags));
 }
 
 void GraphicsContext::DrawRRect(const SkRRect& rrect, const PaintFlags& flags) {
   if (ContextDisabled())
     return;
   DCHECK(canvas_);
 
-  canvas_->drawRRect(rrect, flags);
+  canvas_->drawRRect(rrect, ApplyHighContrastFilter(&flags));
 }
 
 void GraphicsContext::FillPath(const Path& path_to_fill) {
   if (ContextDisabled() || path_to_fill.IsEmpty())
     return;
 
   DrawPath(path_to_fill.GetSkPath(), ImmutableState()->FillFlags());
 }
 
 void GraphicsContext::FillRect(const FloatRect& rect) {
@@ skipping 99 matching lines @@
                                  const Color& color) {
   if (ContextDisabled())
     return;
   DCHECK(canvas_);
 
   if (!IsSimpleDRRect(outer, inner)) {
     if (color == FillColor()) {
       canvas_->drawDRRect(outer, inner, ImmutableState()->FillFlags());
     } else {
       PaintFlags flags(ImmutableState()->FillFlags());
-      flags.setColor(color.Rgb());
+      flags.setColor(ApplyHighContrastFilter(color).Rgb());
       canvas_->drawDRRect(outer, inner, flags);
     }
 
     return;
   }
 
   // We can draw this as a stroked rrect.
   float stroke_width = inner.Rect().X() - outer.Rect().X();
   SkRRect stroke_r_rect = outer;
   stroke_r_rect.inset(stroke_width / 2, stroke_width / 2);
 
   PaintFlags stroke_flags(ImmutableState()->FillFlags());
-  stroke_flags.setColor(color.Rgb());
+  stroke_flags.setColor(ApplyHighContrastFilter(color).Rgb());
   stroke_flags.setStyle(PaintFlags::kStroke_Style);
   stroke_flags.setStrokeWidth(stroke_width);
 
   canvas_->drawRRect(stroke_r_rect, stroke_flags);
 }
 
 void GraphicsContext::FillEllipse(const FloatRect& ellipse) {
   if (ContextDisabled())
     return;
 
@@ skipping 171 matching lines @@
 }
 
 void GraphicsContext::FillRectWithRoundedHole(
     const FloatRect& rect,
     const FloatRoundedRect& rounded_hole_rect,
     const Color& color) {
   if (ContextDisabled())
     return;
 
   PaintFlags flags(ImmutableState()->FillFlags());
-  flags.setColor(color.Rgb());
+  flags.setColor(ApplyHighContrastFilter(color).Rgb());
   canvas_->drawDRRect(SkRRect::MakeRect(rect), rounded_hole_rect, flags);
 }
 
 void GraphicsContext::AdjustLineToPixelBoundaries(FloatPoint& p1,
                                                   FloatPoint& p2,
                                                   float stroke_width,
                                                   StrokeStyle pen_style) {
   // For odd widths, we add in 0.5 to the appropriate x/y so that the float
   // arithmetic works out.  For example, with a border width of 3, WebKit will
   // pass us (y1+y2)/2, e.g., (50+53)/2 = 103/2 = 51 when we want 51.5.  It is
@@ skipping 36 matching lines @@
     case kColorFilterNone:
       break;
     default:
       NOTREACHED();
       break;
   }
 
   return nullptr;
 }
 
+void GraphicsContext::UpdateHighContrastFilterFromSettings() {

[chrishtr, 2017/06/02 21:12:30]

Please unittest these.

[dmazzoni, 2017/06/05 15:56:37]

Done. I didn't see many examples of calling private methods from unit tests,
so I tested it by applying the filter to 1x1 pixel rectangles drawn to a canvas
and then testing the resulting canvas pixels, similar to existing
GraphicsContext
unit tests. Let me know if you think something a little more low-level would be
better, maybe by making the test a friend.

+  SkHighContrastConfig config;
+
+  switch (high_contrast_settings_.mode) {
+    case HighContrastMode::kOff:
+      high_contrast_filter_.reset(nullptr);
+      return;
+    case HighContrastMode::kSimpleInvertForTesting: {
+      uint8_t identity[256], invert[256];
+      for (int i = 0; i < 256; ++i) {
+        identity[i] = i;
+        invert[i] = 255 - i;
+      }
+      high_contrast_filter_ =
+          SkTableColorFilter::MakeARGB(identity, invert, invert, invert);
+      return;
+    }
+    case HighContrastMode::kInvertBrightness:
+      config.fInvertStyle =
+          SkHighContrastConfig::InvertStyle::kInvertBrightness;
+      break;
+    case HighContrastMode::kInvertLightness:
+      config.fInvertStyle = SkHighContrastConfig::InvertStyle::kInvertLightness;
+      break;
+  }
+
+  config.fGrayscale = high_contrast_settings_.grayscale;
+  config.fContrast = high_contrast_settings_.contrast;
+  high_contrast_filter_ = SkHighContrastFilter::Make(config);
+}
+
+Color GraphicsContext::ApplyHighContrastFilter(const Color& input) const {
+  if (!high_contrast_filter_)
+    return input;
+
+  SkColor sk_input =
+      SkColorSetARGB(input.Alpha(), input.Red(), input.Green(), input.Blue());
+  SkColor sk_output = high_contrast_filter_->filterColor(sk_input);
+  return Color(MakeRGBA(SkColorGetR(sk_output), SkColorGetG(sk_output),
+                        SkColorGetB(sk_output), SkColorGetA(sk_output)));
+}
+
+PaintFlags GraphicsContext::ApplyHighContrastFilter(
+    const PaintFlags* input) const {
+  if (input && !high_contrast_filter_)
+    return *input;
+
+  PaintFlags output;
+  if (input)
+    output = *input;
+  if (output.getShader()) {
+    output.setColorFilter(high_contrast_filter_);
+  } else {
+    output.setColor(high_contrast_filter_->filterColor(output.getColor()));
+  }
+  return output;
+}
+
 }  // namespace blink