Move isValid/isCurrentColor from Color to StyleColor

Source/core/accessibility/AccessibilityTable.cpp

 /*
  * Copyright (C) 2008 Apple 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 128 matching lines @@
         return false;
 
     // If there are at least 20 rows, we'll call it a data table.
     if (numRows >= 20)
         return true;
     
     // Store the background color of the table to check against cell's background colors.
     RenderStyle* tableStyle = table->style();
     if (!tableStyle)
         return false;
-    Color tableBGColor = tableStyle->visitedDependentColor(CSSPropertyBackgroundColor);
+    StyleColor tableBGColor = tableStyle->visitedDependentColor(CSSPropertyBackgroundColor);
     
     // check enough of the cells to find if the table matches our criteria
     // Criteria: 
     //   1) must have at least one valid cell (and)
     //   2) at least half of cells have borders (or)
     //   3) at least half of cells have different bg colors than the table, and there is cell spacing
     unsigned validCellCount = 0;
     unsigned borderedCellCount = 0;
     unsigned backgroundDifferenceCellCount = 0;
     unsigned cellsWithTopBorder = 0;
     unsigned cellsWithBottomBorder = 0;
     unsigned cellsWithLeftBorder = 0;
     unsigned cellsWithRightBorder = 0;
     
-    Color alternatingRowColors[5];
+    StyleColor alternatingRowColors[5];
     int alternatingRowColorCount = 0;
     
     int headersInFirstColumnCount = 0;
     for (int row = 0; row < numRows; ++row) {
     
         int headersInFirstRowCount = 0;
         for (int col = 0; col < numCols; ++col) {    
             RenderTableCell* cell = firstBody->primaryCellAt(row, col);
             if (!cell)
                 continue;
@@ skipping 41 matching lines @@
                 cellsWithTopBorder++;
             if (cell->borderBottom() > 0)
                 cellsWithBottomBorder++;
             if (cell->borderLeft() > 0)
                 cellsWithLeftBorder++;
             if (cell->borderRight() > 0)
                 cellsWithRightBorder++;
             
             // If the cell has a different color from the table and there is cell spacing,
             // then it is probably a data table cell (spacing and colors take the place of borders).
-            Color cellColor = renderStyle->visitedDependentColor(CSSPropertyBackgroundColor);
+            StyleColor cellColor = renderStyle->visitedDependentColor(CSSPropertyBackgroundColor);
             if (table->hBorderSpacing() > 0 && table->vBorderSpacing() > 0
                 && tableBGColor != cellColor && cellColor.alpha() != 1)
                 backgroundDifferenceCellCount++;
             
             // If we've found 10 "good" cells, we don't need to keep searching.
             if (borderedCellCount >= 10 || backgroundDifferenceCellCount >= 10)
                 return true;
             
             // For the first 5 rows, cache the background color so we can check if this table has zebra-striped rows.
             if (row < 5 && row == alternatingRowColorCount) {
                 RenderObject* renderRow = cell->parent();
                 if (!renderRow || !renderRow->isBoxModelObject() || !toRenderBoxModelObject(renderRow)->isTableRow())
                     continue;
                 RenderStyle* rowRenderStyle = renderRow->style();
                 if (!rowRenderStyle)
                     continue;
-                Color rowColor = rowRenderStyle->visitedDependentColor(CSSPropertyBackgroundColor);
+                StyleColor rowColor = rowRenderStyle->visitedDependentColor(CSSPropertyBackgroundColor);
                 alternatingRowColors[alternatingRowColorCount] = rowColor;
                 alternatingRowColorCount++;
             }
         }
         
         if (!row && headersInFirstRowCount == numCols && numCols > 1)
             return true;
     }
 
     if (headersInFirstColumnCount == numRows && numRows > 1)
@@ skipping 11 matching lines @@
         || cellsWithLeftBorder >= neededCellCount
         || cellsWithRightBorder >= neededCellCount)
         return true;
     
     // half had different background colors, it's a data table
     if (backgroundDifferenceCellCount >= neededCellCount)
         return true;
 
     // Check if there is an alternating row background color indicating a zebra striped style pattern.
     if (alternatingRowColorCount > 2) {
-        Color firstColor = alternatingRowColors[0];
+        StyleColor firstColor = alternatingRowColors[0];
         for (int k = 1; k < alternatingRowColorCount; k++) {
             // If an odd row was the same color as the first row, its not alternating.
             if (k % 2 == 1 && alternatingRowColors[k] == firstColor)
                 return false;
             // If an even row is not the same as the first row, its not alternating.
             if (!(k % 2) && alternatingRowColors[k] != firstColor)
                 return false;
         }
         return true;
     }
@@ skipping 255 matching lines @@
     }
 
     // try the standard 
     if (title.isEmpty())
         title = AccessibilityRenderObject::title();
     
     return title;
 }
 
 } // namespace WebCore