Native Themes: Add table header colors

ui/views/controls/table/table_header.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/views/controls/table/table_header.h"
 
 #include <stddef.h>
 
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkPaint.h"
@@ skipping 15 matching lines @@
 
 // The minimum width we allow a column to go down to.
 const int kMinColumnWidth = 10;
 
 // Distace from edge columns can be resized by.
 const int kResizePadding = 5;
 
 // Amount of space above/below the separator.
 const int kSeparatorPadding = 4;
 
-const SkColor kTextColor = SK_ColorBLACK;
-const SkColor kBackgroundColor1 = SkColorSetRGB(0xF9, 0xF9, 0xF9);
-const SkColor kBackgroundColor2 = SkColorSetRGB(0xE8, 0xE8, 0xE8);
-const SkColor kSeparatorColor = SkColorSetRGB(0xAA, 0xAA, 0xAA);
-
 // Size of the sort indicator (doesn't include padding).
 const int kSortIndicatorSize = 8;
 
 }  // namespace
 
 // static
 const char TableHeader::kViewClassName[] = "TableHeader";
 // static
 const int TableHeader::kHorizontalPadding = 7;
 // static
 const int TableHeader::kSortIndicatorWidth = kSortIndicatorSize +
     TableHeader::kHorizontalPadding * 2;
 
 typedef std::vector<TableView::VisibleColumn> Columns;
 
-TableHeader::TableHeader(TableView* table) : table_(table) {
-  set_background(Background::CreateVerticalGradientBackground(
-                     kBackgroundColor1, kBackgroundColor2));
-}
+TableHeader::TableHeader(TableView* table) : table_(table) {}
 
-TableHeader::~TableHeader() {
-}
+TableHeader::~TableHeader() {}
 
 void TableHeader::Layout() {
   SetBounds(x(), y(), table_->width(), GetPreferredSize().height());
 }
 
 void TableHeader::OnPaint(gfx::Canvas* canvas) {
+  ui::NativeTheme* theme = GetNativeTheme();
+  const SkColor text_color =
+      theme->GetSystemColor(ui::NativeTheme::kColorId_TableHeaderText);
+  const SkColor separator_color =
+      theme->GetSystemColor(ui::NativeTheme::kColorId_TableHeaderSeparator);
   // Paint the background and a separator at the bottom. The separator color
   // matches that of the border around the scrollview.
   OnPaintBackground(canvas);
-  SkColor border_color = GetNativeTheme()->GetSystemColor(
-      ui::NativeTheme::kColorId_UnfocusedBorderColor);
+  SkColor border_color =
+      theme->GetSystemColor(ui::NativeTheme::kColorId_UnfocusedBorderColor);
   canvas->DrawLine(gfx::Point(0, height() - 1),
                    gfx::Point(width(), height() - 1), border_color);
 
   const Columns& columns = table_->visible_columns();
   const int sorted_column_id = table_->sort_descriptors().empty() ? -1 :
       table_->sort_descriptors()[0].column_id;
   for (size_t i = 0; i < columns.size(); ++i) {
     if (columns[i].width >= 2) {
       const int separator_x = GetMirroredXInView(
           columns[i].x + columns[i].width - 1);
       canvas->DrawLine(gfx::Point(separator_x, kSeparatorPadding),
                        gfx::Point(separator_x, height() - kSeparatorPadding),
-                       kSeparatorColor);
+                       separator_color);
     }
 
     const int x = columns[i].x + kHorizontalPadding;
     int width = columns[i].width - kHorizontalPadding - kHorizontalPadding;
     if (width <= 0)
       continue;
 
     const int title_width =
         gfx::GetStringWidth(columns[i].column.title, font_list_);
     const bool paint_sort_indicator =
         (columns[i].column.id == sorted_column_id &&
          title_width + kSortIndicatorWidth <= width);
 
     if (paint_sort_indicator &&
         columns[i].column.alignment == ui::TableColumn::RIGHT) {
       width -= kSortIndicatorWidth;
     }
 
     canvas->DrawStringRectWithFlags(
-        columns[i].column.title, font_list_, kTextColor,
+        columns[i].column.title, font_list_, text_color,
         gfx::Rect(GetMirroredXWithWidthInView(x, width), kVerticalPadding,
                   width, height() - kVerticalPadding * 2),
         TableColumnAlignmentToCanvasAlignment(columns[i].column.alignment));
 
     if (paint_sort_indicator) {
       SkPaint paint;
-      paint.setColor(kTextColor);
+      paint.setColor(text_color);
       paint.setStyle(SkPaint::kFill_Style);
       paint.setAntiAlias(true);
 
       int indicator_x = 0;
       ui::TableColumn::Alignment alignment = columns[i].column.alignment;
       if (base::i18n::IsRTL()) {
         if (alignment == ui::TableColumn::LEFT)
           alignment = ui::TableColumn::RIGHT;
         else if (alignment == ui::TableColumn::RIGHT)
           alignment = ui::TableColumn::LEFT;
@@ skipping 98 matching lines @@
       break;
     case ui::ET_GESTURE_SCROLL_END:
       resize_details_.reset();
       break;
     default:
       return;
   }
   event->SetHandled();
 }
 
+void TableHeader::OnNativeThemeChanged(const ui::NativeTheme* theme) {
+  set_background(Background::CreateSolidBackground(
+      theme->GetSystemColor(ui::NativeTheme::kColorId_TableHeaderBackground)));
+}
+
 bool TableHeader::StartResize(const ui::LocatedEvent& event) {
   if (is_resizing())
     return false;
 
   const int index = GetResizeColumn(GetMirroredXInView(event.x()));
   if (index == -1)
     return false;
 
   resize_details_.reset(new ColumnResizeDetails);
   resize_details_->column_index = index;
@@ skipping 37 matching lines @@
   if (index > 0 && x >= column.x - kResizePadding &&
       x <= column.x + kResizePadding) {
     return index - 1;
   }
   const int max_x = column.x + column.width;
   return (x >= max_x - kResizePadding && x <= max_x + kResizePadding) ?
       index : -1;
 }
 
 }  // namespace views