test_runner: Rename WebTestThemeEngineMock to MockWebThemeEngine.

content/shell/renderer/test_runner/mock_web_theme_engine.cc

 // Copyright 2013 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 "content/shell/renderer/test_runner/WebTestThemeEngineMock.h"
+#include "content/shell/renderer/test_runner/mock_web_theme_engine.h"
 
 #include "base/logging.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 #include "third_party/skia/include/core/SkRect.h"
 
 using blink::WebCanvas;
 using blink::WebColor;
 using blink::WebRect;
 using blink::WebThemeEngine;
 
 namespace content {
 
-static const SkColor edgeColor     = SK_ColorBLACK;
-static const SkColor readOnlyColor = SkColorSetRGB(0xe9, 0xc2, 0xa6);
+namespace {
+
+const SkColor edgeColor = SK_ColorBLACK;
+const SkColor readOnlyColor = SkColorSetRGB(0xe9, 0xc2, 0xa6);
+
+}  // namespace
 
 SkColor bgColors(WebThemeEngine::State state) {
   switch (state) {
     case WebThemeEngine::StateDisabled:
       return SkColorSetRGB(0xc9, 0xc9, 0xc9);
     case WebThemeEngine::StateHover:
       return SkColorSetRGB(0x43, 0xf9, 0xff);
     case WebThemeEngine::StateNormal:
       return SkColorSetRGB(0x89, 0xc4, 0xff);
     case WebThemeEngine::StatePressed:
       return SkColorSetRGB(0xa9, 0xff, 0x12);
     case WebThemeEngine::StateFocused:
       return SkColorSetRGB(0x00, 0xf3, 0xac);
     case WebThemeEngine::StateReadonly:
       return SkColorSetRGB(0xf3, 0xe0, 0xd0);
     default:
       NOTREACHED();
   }
   return SkColorSetRGB(0x00, 0x00, 0xff);
 }
 
-blink::WebSize WebTestThemeEngineMock::getSize(WebThemeEngine::Part part)
-{
+blink::WebSize MockWebThemeEngine::getSize(WebThemeEngine::Part part) {
     // FIXME: We use this constant to indicate we are being asked for the size of
     // a part that we don't expect to be asked about. We return a garbage value
     // rather than just asserting because this code doesn't have access to either
     // WTF or base to raise an assertion or do any logging :(.
     const blink::WebSize invalidPartSize = blink::WebSize(100, 100);
 
     switch (part) {
     case WebThemeEngine::PartScrollbarLeftArrow:
         return blink::WebSize(17, 15);
     case WebThemeEngine::PartScrollbarRightArrow:
@@ skipping 15 matching lines @@
         return blink::WebSize(13, 13);
     case WebThemeEngine::PartSliderThumb:
         return blink::WebSize(11, 21);
     case WebThemeEngine::PartInnerSpinButton:
         return blink::WebSize(15, 8);
     default:
         return invalidPartSize;
     }
 }
 
-static SkIRect webRectToSkIRect(const WebRect& webRect)
-{
+static SkIRect webRectToSkIRect(const WebRect& webRect) {
     SkIRect irect;
     irect.set(webRect.x, webRect.y,
         webRect.x + webRect.width - 1, webRect.y + webRect.height - 1);
     return irect;
 }
 
-static SkIRect validate(const SkIRect& rect, WebThemeEngine::Part part)
-{
+static SkIRect validate(const SkIRect& rect, WebThemeEngine::Part part) {
     switch (part) {
     case WebThemeEngine::PartCheckbox:
     case WebThemeEngine::PartRadio: {
         SkIRect retval = rect;
 
         // The maximum width and height is 13.
         // Center the square in the passed rectangle.
         const int maxControlSize = 13;
         int controlSize = std::min(rect.width(), rect.height());
         controlSize = std::min(controlSize, maxControlSize);
 
         retval.fLeft   = rect.fLeft + (rect.width() / 2) - (controlSize / 2);
         retval.fRight  = retval.fLeft + controlSize - 1;
         retval.fTop    = rect.fTop + (rect.height() / 2) - (controlSize / 2);
         retval.fBottom = retval.fTop + controlSize - 1;
 
         return retval;
     }
     default:
         return rect;
     }
 }
 
-
-void box(SkCanvas *canvas, const SkIRect& rect, SkColor fillColor)
-{
+void box(SkCanvas* canvas, const SkIRect& rect, SkColor fillColor) {
     SkPaint paint;
 
     paint.setStyle(SkPaint::kFill_Style);
     paint.setColor(fillColor);
     canvas->drawIRect(rect, paint);
 
     paint.setColor(edgeColor);
     paint.setStyle(SkPaint::kStroke_Style);
     canvas->drawIRect(rect, paint);
 }
 
-void line(SkCanvas *canvas, int x0, int y0, int x1, int y1, SkColor color)
-{
+void line(SkCanvas* canvas, int x0, int y0, int x1, int y1, SkColor color) {
     SkPaint paint;
     paint.setColor(color);
-    canvas->drawLine(SkIntToScalar(x0), SkIntToScalar(y0),
-        SkIntToScalar(x1), SkIntToScalar(y1), paint);
+    canvas->drawLine(SkIntToScalar(x0),
+                     SkIntToScalar(y0),
+                     SkIntToScalar(x1),
+                     SkIntToScalar(y1),
+                     paint);
 }
 
-void triangle(SkCanvas *canvas,
-    int x0, int y0,
-    int x1, int y1,
-    int x2, int y2,
-    SkColor color)
-{
+void triangle(SkCanvas* canvas,
+              int x0,
+              int y0,
+              int x1,
+              int y1,
+              int x2,
+              int y2,
+              SkColor color) {
     SkPath path;
     SkPaint paint;
 
     paint.setColor(color);
     paint.setStyle(SkPaint::kFill_Style);
     path.incReserve(4);
     path.moveTo(SkIntToScalar(x0), SkIntToScalar(y0));
     path.lineTo(SkIntToScalar(x1), SkIntToScalar(y1));
     path.lineTo(SkIntToScalar(x2), SkIntToScalar(y2));
     path.close();
     canvas->drawPath(path, paint);
 
     paint.setColor(edgeColor);
     paint.setStyle(SkPaint::kStroke_Style);
     canvas->drawPath(path, paint);
 }
 
-void roundRect(SkCanvas *canvas, SkIRect irect, SkColor color)
-{
+void roundRect(SkCanvas* canvas, SkIRect irect, SkColor color) {
     SkRect rect;
     SkScalar radius = SkIntToScalar(5);
     SkPaint paint;
 
     rect.set(irect);
     paint.setColor(color);
     paint.setStyle(SkPaint::kFill_Style);
     canvas->drawRoundRect(rect, radius, radius, paint);
 
     paint.setColor(edgeColor);
     paint.setStyle(SkPaint::kStroke_Style);
     canvas->drawRoundRect(rect, radius, radius, paint);
 }
 
-void oval(SkCanvas* canvas, SkIRect irect, SkColor color)
-{
+void oval(SkCanvas* canvas, SkIRect irect, SkColor color) {
     SkRect rect;
     SkPaint paint;
 
     rect.set(irect);
     paint.setColor(color);
     paint.setStyle(SkPaint::kFill_Style);
     canvas->drawOval(rect, paint);
 
     paint.setColor(edgeColor);
     paint.setStyle(SkPaint::kStroke_Style);
     canvas->drawOval(rect, paint);
 }
 
-void circle(SkCanvas *canvas, SkIRect irect, SkScalar radius, SkColor color)
-{
+void circle(SkCanvas* canvas, SkIRect irect, SkScalar radius, SkColor color) {
     int left = irect.fLeft;
     int width = irect.width();
     int height = irect.height();
     int top = irect.fTop;
 
     SkScalar cy = SkIntToScalar(top  + height / 2);
     SkScalar cx = SkIntToScalar(left + width / 2);
     SkPaint paint;
 
     paint.setColor(color);
     paint.setStyle(SkPaint::kFill_Style);
     canvas->drawCircle(cx, cy, radius, paint);
 
     paint.setColor(edgeColor);
     paint.setStyle(SkPaint::kStroke_Style);
     canvas->drawCircle(cx, cy, radius, paint);
 }
 
-void nestedBoxes(SkCanvas *canvas,
-    SkIRect irect,
-    int indentLeft,
-    int indentTop,
-    int indentRight,
-    int indentBottom,
-    SkColor outerColor,
-    SkColor innerColor)
-{
+void nestedBoxes(SkCanvas* canvas,
+                 SkIRect irect,
+                 int indentLeft,
+                 int indentTop,
+                 int indentRight,
+                 int indentBottom,
+                 SkColor outerColor,
+                 SkColor innerColor) {
     SkIRect lirect;
     box(canvas, irect, outerColor);
     lirect.set(irect.fLeft + indentLeft,
         irect.fTop + indentTop,
         irect.fRight - indentRight,
         irect.fBottom - indentBottom);
     box(canvas, lirect, innerColor);
 }
 
 void insetBox(SkCanvas* canvas,
               SkIRect irect,
               int indentLeft,
               int indentTop,
               int indentRight,
               int indentBottom,
               SkColor color) {
   SkIRect lirect;
   lirect.set(irect.fLeft + indentLeft,
              irect.fTop + indentTop,
              irect.fRight - indentRight,
              irect.fBottom - indentBottom);
   box(canvas, lirect, color);
 }
 
-void markState(SkCanvas *canvas, SkIRect irect, WebThemeEngine::State state)
-{
+void markState(SkCanvas* canvas, SkIRect irect, WebThemeEngine::State state) {
     int left = irect.fLeft;
     int right = irect.fRight;
     int top = irect.fTop;
     int bottom = irect.fBottom;
 
     // The length of a triangle side for the corner marks.
     const int triangleSize = 5;
 
     switch (state) {
     case WebThemeEngine::StateDisabled:
@@ skipping 37 matching lines @@
             edgeColor);
         break;
 
     default:
         // FIXME: Should we do something here to indicate that we got an invalid state?
         // Unfortunately, we can't assert because we don't have access to WTF or base.
         break;
     }
 }
 
-void WebTestThemeEngineMock::paint(
-    blink::WebCanvas* canvas,
-    WebThemeEngine::Part part,
-    WebThemeEngine::State state,
-    const blink::WebRect& rect,
-    const WebThemeEngine::ExtraParams* extraParams)
-{
+void MockWebThemeEngine::paint(blink::WebCanvas* canvas,
+                               WebThemeEngine::Part part,
+                               WebThemeEngine::State state,
+                               const blink::WebRect& rect,
+                               const WebThemeEngine::ExtraParams* extraParams) {
     SkIRect irect = webRectToSkIRect(rect);
     SkPaint paint;
 
     // Indent amounts for the check in a checkbox or radio button.
     const int checkIndent = 3;
 
     // Indent amounts for short and long sides of the scrollbar notches.
     const int notchLongOffset = 1;
     const int notchShortOffset = 4;
     const int noOffset = 0;
@@ skipping 321 matching lines @@
         break;
     }
     default:
         // FIXME: Should we do something here to indicate that we got an invalid part?
         // Unfortunately, we can't assert because we don't have access to WTF or base.
         break;
     }
 }
 
 }  // namespace content