Add 1px black border for ChromeOS status button.

gfx/canvas_skia_linux.cc

 // Copyright (c) 2009 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 "gfx/canvas_skia.h"
 
 #include <cairo/cairo.h>
 #include <gtk/gtk.h>
 #include <pango/pango.h>
 #include <pango/pangocairo.h>
@@ skipping 190 matching lines @@
     // asked for. See the loop in pango-layout.c process_item that determines
     // where to wrap.
     *width = org_width;
   }
 
   g_object_unref(layout);
   cairo_destroy(cr);
   cairo_surface_destroy(surface);
 }
 
-void CanvasSkia::DrawStringInt(const std::wstring& text,
-                               const gfx::Font& font,
-                               const SkColor& color,
-                               int x, int y, int w, int h,
-                               int flags) {
+void CanvasSkia::DrawStringWithHalo(const std::wstring& text,

[DaveMoore, 2010/11/17 01:07:43]

I don't think this method should be called "DrawStringWithHalo()" as it can be
used to draw a string with no halo. It's code should be shared with
DrawStringInt() some other way.

[xiyuan, 2010/11/17 17:59:22]

One possible way to share is wrapping the common code into
PreDrawingString/PostDrawingString and have DrawStringInt and DrawStringWithHalo
call them separately. 

Is this what you mean? Could you shed more lights on this? Thanks.

+                                    const gfx::Font& font,
+                                    const SkColor& text_color,
+                                    const SkColor& halo_color,
+                                    int x, int y, int w, int h,
+                                    int flags) {
   if (w <= 0 || h <= 0)
     return;
 
+  bool has_halo = text_color != halo_color;
+
   cairo_t* cr = beginPlatformPaint();
   PangoLayout* layout = pango_cairo_create_layout(cr);
 
   SetupPangoLayout(layout, text, font, w, flags);
 
   pango_layout_set_height(layout, h * PANGO_SCALE);
 
   cairo_save(cr);
-  cairo_set_source_rgba(cr,
-                        SkColorGetR(color) / 255.0,
-                        SkColorGetG(color) / 255.0,
-                        SkColorGetB(color) / 255.0,
-                        SkColorGetA(color) / 255.0);
 
   int width, height;
   pango_layout_get_pixel_size(layout, &width, &height);
 
-  cairo_rectangle(cr, x, y, w, h);
+  // Use a bigger clip rect for text with halo.
+  if (has_halo)
+    cairo_rectangle(cr, x - 1, y - 1, w + 2, h + 2);
+  else
+    cairo_rectangle(cr, x, y, w, h);
   cairo_clip(cr);
 
   if (flags & Canvas::TEXT_VALIGN_TOP) {
     // Cairo should draw from the top left corner already.
   } else if (flags & Canvas::TEXT_VALIGN_BOTTOM) {
     y += (h - height);
   } else {
     // Vertically centered.
     y += ((h - height) / 2);
   }
 
-  cairo_move_to(cr, x, y);
-  pango_cairo_show_layout(cr, layout);
+  if (has_halo) {
+    CanvasSkia text_canvas(w + 2, h + 2, false);
+    text_canvas.FillRectInt(static_cast<SkColor>(0), 0, 0, w + 2, h + 2);
+
+    cairo_t* text_cr = text_canvas.beginPlatformPaint();
+
+    cairo_move_to(text_cr, 1, 1);
+    pango_cairo_layout_path(text_cr, layout);
+
+    cairo_set_source_rgba(text_cr,
+                          SkColorGetR(halo_color) / 255.0,
+                          SkColorGetG(halo_color) / 255.0,
+                          SkColorGetB(halo_color) / 255.0,
+                          SkColorGetA(halo_color) / 255.0);
+    cairo_set_line_width(text_cr, 2.0);
+    cairo_stroke_preserve(text_cr);
+
+    cairo_set_operator(text_cr, CAIRO_OPERATOR_SOURCE);
+    cairo_set_source_rgba(text_cr,
+                          SkColorGetR(text_color) / 255.0,
+                          SkColorGetG(text_color) / 255.0,
+                          SkColorGetB(text_color) / 255.0,
+                          SkColorGetA(text_color) / 255.0);
+    cairo_fill(text_cr);
+
+    text_canvas.endPlatformPaint();
+
+    const SkBitmap& text_bitmap = const_cast<SkBitmap&>(
+        text_canvas.getTopPlatformDevice().accessBitmap(false));
+    DrawBitmapInt(text_bitmap, x - 1, y - 1);
+  } else {
+    cairo_move_to(cr, x, y);
+    cairo_set_source_rgba(cr,
+                          SkColorGetR(text_color) / 255.0,
+                          SkColorGetG(text_color) / 255.0,
+                          SkColorGetB(text_color) / 255.0,
+                          SkColorGetA(text_color) / 255.0);
+    pango_cairo_show_layout(cr, layout);
+  }
+
   if (font.GetStyle() & gfx::Font::UNDERLINED) {
     gfx::PlatformFontGtk* platform_font =
         static_cast<gfx::PlatformFontGtk*>(font.platform_font());
     double underline_y =
         static_cast<double>(y) + height + platform_font->underline_position();
     cairo_set_line_width(cr, platform_font->underline_thickness());
     cairo_move_to(cr, x, underline_y);
     cairo_line_to(cr, x + width, underline_y);
     cairo_stroke(cr);
   }
   cairo_restore(cr);
 
   g_object_unref(layout);
   // NOTE: beginPlatformPaint returned its surface, we shouldn't destroy it.
 }
 
+void CanvasSkia::DrawStringInt(const std::wstring& text,
+                               const gfx::Font& font,
+                               const SkColor& color,
+                               int x, int y, int w, int h,
+                               int flags) {
+  DrawStringWithHalo(text, font, color, color, x, y, w, h, flags);
+}
+
 void CanvasSkia::DrawGdkPixbuf(GdkPixbuf* pixbuf, int x, int y) {
   if (!pixbuf) {
     NOTREACHED();
     return;
   }
 
   cairo_t* cr = beginPlatformPaint();
   gdk_cairo_set_source_pixbuf(cr, pixbuf, x, y);
   cairo_paint(cr);
 }
 
 }  // namespace gfx