Remove deferred fade shader workaround from RenderText

ui/gfx/render_text.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/render_text.h"
 
 #include <algorithm>
 #include <climits>
 
 #include "base/command_line.h"
@@ skipping 171 matching lines @@
       started_drawing_(false),
       underline_thickness_(kUnderlineMetricsNotSet),
       underline_position_(0.0f) {
   DCHECK(canvas_skia_);
   paint_.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
   paint_.setStyle(SkPaint::kFill_Style);
   paint_.setAntiAlias(true);
   paint_.setSubpixelText(true);
   paint_.setLCDRenderText(true);
   paint_.setHinting(SkPaint::kNormal_Hinting);
-  bounds_.setEmpty();
 }
 
 SkiaTextRenderer::~SkiaTextRenderer() {
-  // Work-around for http://crbug.com/122743, where non-ClearType text is
-  // rendered with incorrect gamma when using the fade shader. Draw the text
-  // to a layer and restore it faded by drawing a rect in kDstIn_Mode mode.
-  //
-  // TODO(asvitkine): Remove this work-around once the Skia bug is fixed.
-  //                  http://code.google.com/p/skia/issues/detail?id=590
-  if (deferred_fade_shader_.get()) {
-    paint_.setShader(deferred_fade_shader_.get());
-    paint_.setXfermodeMode(SkXfermode::kDstIn_Mode);
-    canvas_skia_->drawRect(bounds_, paint_);
-    canvas_skia_->restore();
-  }
 }
 
 void SkiaTextRenderer::SetDrawLooper(SkDrawLooper* draw_looper) {
   paint_.setLooper(draw_looper);
 }
 
 void SkiaTextRenderer::SetFontRenderParams(const FontRenderParams& params,
                                            bool background_is_transparent) {
   ApplyRenderParams(params, background_is_transparent, &paint_);
 }
@@ skipping 18 matching lines @@
     // Enable fake bold text if bold style is needed but new typeface does not
     // have it.
     paint_.setFakeBoldText((style & Font::BOLD) && !typeface->isBold());
   }
 }
 
 void SkiaTextRenderer::SetForegroundColor(SkColor foreground) {
   paint_.setColor(foreground);
 }
 
-void SkiaTextRenderer::SetShader(SkShader* shader, const Rect& bounds) {
-  bounds_ = RectToSkRect(bounds);
+void SkiaTextRenderer::SetShader(SkShader* shader) {
   paint_.setShader(shader);
 }
 
 void SkiaTextRenderer::SetUnderlineMetrics(SkScalar thickness,
                                            SkScalar position) {
   underline_thickness_ = thickness;
   underline_position_ = position;
 }
 
 void SkiaTextRenderer::DrawPosText(const SkPoint* pos,
                                    const uint16* glyphs,
                                    size_t glyph_count) {
-  if (!started_drawing_) {
-    started_drawing_ = true;
-    // Work-around for http://crbug.com/122743, where non-ClearType text is
-    // rendered with incorrect gamma when using the fade shader. Draw the text
-    // to a layer and restore it faded by drawing a rect in kDstIn_Mode mode.
-    //
-    // Skip this when there is a looper which seems not working well with
-    // deferred paint. Currently a looper is only used for text shadows.
-    //
-    // TODO(asvitkine): Remove this work-around once the Skia bug is fixed.
-    //                  http://code.google.com/p/skia/issues/detail?id=590
-    if (!paint_.isLCDRenderText() &&
-        paint_.getShader() &&
-        !paint_.getLooper()) {
-      deferred_fade_shader_ = skia::SharePtr(paint_.getShader());
-      paint_.setShader(NULL);
-      canvas_skia_->saveLayer(&bounds_, NULL);
-    }
-  }
-
   const size_t byte_length = glyph_count * sizeof(glyphs[0]);
   canvas_skia_->drawPosText(&glyphs[0], byte_length, &pos[0], paint_);
 }
 
 void SkiaTextRenderer::DrawDecorations(int x, int y, int width, bool underline,
                                        bool strike, bool diagonal_strike) {
   if (underline)
     DrawUnderline(x, y, width);
   if (strike)
     DrawStrike(x, y, width);
@@ skipping 878 matching lines @@
     solid_part.Inset(0, 0, gradient_width, 0);
   }
 
   Rect text_rect = display_rect();
   text_rect.Inset(GetAlignmentOffset(0).x(), 0, 0, 0);
 
   // TODO(msw): Use the actual text colors corresponding to each faded part.
   skia::RefPtr<SkShader> shader = CreateFadeShader(
       text_rect, left_part, right_part, colors_.breaks().front().second);
   if (shader)
-    renderer->SetShader(shader.get(), display_rect());
+    renderer->SetShader(shader.get());
 }
 
 void RenderText::ApplyTextShadows(internal::SkiaTextRenderer* renderer) {
   skia::RefPtr<SkDrawLooper> looper = CreateShadowDrawLooper(shadows_);
   renderer->SetDrawLooper(looper.get());
 }
 
 // static
 bool RenderText::RangeContainsCaret(const Range& range,
                                     size_t caret_pos,
@@ skipping 242 matching lines @@
   SetDisplayOffset(display_offset_.x() + delta_x);
 }
 
 void RenderText::DrawSelection(Canvas* canvas) {
   const std::vector<Rect> sel = GetSubstringBounds(selection());
   for (std::vector<Rect>::const_iterator i = sel.begin(); i < sel.end(); ++i)
     canvas->FillRect(*i, selection_background_focused_color_);
 }
 
 }  // namespace gfx