2010-12-21 Mihai Parparita <mihaip@chromium.org>
authormihaip@chromium.org <mihaip@chromium.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 21 Dec 2010 20:15:53 +0000 (20:15 +0000)
committermihaip@chromium.org <mihaip@chromium.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 21 Dec 2010 20:15:53 +0000 (20:15 +0000)
        Reviewed by Darin Fisher.

        [Chromium] Rename WebThemeEngine/ControlDRT to WebThemeEngine/ControlDRTWin
        https://bugs.webkit.org/show_bug.cgi?id=51406

        Rename WebThemeControlDRT to WebThemeControlDRTWin and WebThemeEngineDRT
        to WebThemeEngineDRTWin and update references everywhere.

        * DumpRenderTree/DumpRenderTree.gypi:
        * DumpRenderTree/chromium/TestShellWin.cpp:
        * DumpRenderTree/chromium/WebThemeControlDRTWin.cpp: Renamed from Tools/DumpRenderTree/chromium/WebThemeControlDRT.cpp.
        * DumpRenderTree/chromium/WebThemeControlDRTWin.h: Renamed from Tools/DumpRenderTree/chromium/WebThemeControlDRT.h.
        * DumpRenderTree/chromium/WebThemeEngineDRTWin.cpp: Renamed from Tools/DumpRenderTree/chromium/WebThemeEngineDRT.cpp.
        * DumpRenderTree/chromium/WebThemeEngineDRTWin.h: Renamed from Tools/DumpRenderTree/chromium/WebThemeEngineDRT.h.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@74421 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Tools/ChangeLog
Tools/DumpRenderTree/DumpRenderTree.gypi
Tools/DumpRenderTree/chromium/TestShellWin.cpp
Tools/DumpRenderTree/chromium/WebThemeControlDRTWin.cpp [moved from Tools/DumpRenderTree/chromium/WebThemeControlDRT.cpp with 90% similarity]
Tools/DumpRenderTree/chromium/WebThemeControlDRTWin.h [moved from Tools/DumpRenderTree/chromium/WebThemeControlDRT.h with 93% similarity]
Tools/DumpRenderTree/chromium/WebThemeEngineDRTWin.cpp [moved from Tools/DumpRenderTree/chromium/WebThemeEngineDRT.cpp with 52% similarity]
Tools/DumpRenderTree/chromium/WebThemeEngineDRTWin.h [moved from Tools/DumpRenderTree/chromium/WebThemeEngineDRT.h with 94% similarity]

index 9d97b9b..7802f91 100644 (file)
@@ -1,3 +1,20 @@
+2010-12-21  Mihai Parparita  <mihaip@chromium.org>
+
+        Reviewed by Darin Fisher.
+
+        [Chromium] Rename WebThemeEngine/ControlDRT to WebThemeEngine/ControlDRTWin
+        https://bugs.webkit.org/show_bug.cgi?id=51406 
+        
+        Rename WebThemeControlDRT to WebThemeControlDRTWin and WebThemeEngineDRT
+        to WebThemeEngineDRTWin and update references everywhere.
+
+        * DumpRenderTree/DumpRenderTree.gypi:
+        * DumpRenderTree/chromium/TestShellWin.cpp:
+        * DumpRenderTree/chromium/WebThemeControlDRTWin.cpp: Renamed from Tools/DumpRenderTree/chromium/WebThemeControlDRT.cpp.
+        * DumpRenderTree/chromium/WebThemeControlDRTWin.h: Renamed from Tools/DumpRenderTree/chromium/WebThemeControlDRT.h.
+        * DumpRenderTree/chromium/WebThemeEngineDRTWin.cpp: Renamed from Tools/DumpRenderTree/chromium/WebThemeEngineDRT.cpp.
+        * DumpRenderTree/chromium/WebThemeEngineDRTWin.h: Renamed from Tools/DumpRenderTree/chromium/WebThemeEngineDRT.h.
+
 2010-12-21  Anders Carlsson  <andersca@apple.com>
 
         Reviewed by John Sullivan.
index b437eaf..04caee7 100644 (file)
         'conditions': [
             ['OS=="win"', {
                 'drt_files': [
-                    'chromium/WebThemeControlDRT.cpp',
-                    'chromium/WebThemeControlDRT.h',
-                    'chromium/WebThemeEngineDRT.cpp',
-                    'chromium/WebThemeEngineDRT.h',
+                    'chromium/WebThemeControlDRTWin.cpp',
+                    'chromium/WebThemeControlDRTWin.h',
+                    'chromium/WebThemeEngineDRTWin.cpp',
+                    'chromium/WebThemeEngineDRTWin.h',
                 ],
             }],
         ],
index 9efcf5a..3b3ddd9 100644 (file)
@@ -31,7 +31,7 @@
 #include "config.h"
 #include "TestShell.h"
 
-#include "WebThemeEngineDRT.h"
+#include "WebThemeEngineDRTWin.h"
 #include "webkit/support/webkit_support.h"
 #include <fcntl.h>
 #include <io.h>
@@ -49,7 +49,7 @@
     SIZEOF_STRUCT_WITH_SPECIFIED_LAST_MEMBER(NONCLIENTMETRICS, lfMessageFont)
 
 // Theme engine
-static WebThemeEngineDRT themeEngine;
+static WebThemeEngineDRTWin themeEngine;
 
 // Thread main to run for the thread which just tests for timeout.
 unsigned int __stdcall watchDogThread(void* arg)
@@ -35,7 +35,7 @@
 //
 
 #include "config.h"
-#include "WebThemeControlDRT.h"
+#include "WebThemeControlDRTWin.h"
 
 #include "skia/ext/platform_canvas.h"
 #include "skia/ext/skia_utils_win.h"
@@ -63,13 +63,13 @@ static const SkColor bgColors[]    = {
     SkColorSetRGB(0xcc, 0xcc, 0xcc)  // Indeterminate
 };
 
-static SkIRect validate(const SkIRect& rect, WebThemeControlDRT::Type ctype)
+static SkIRect validate(const SkIRect& rect, WebThemeControlDRTWin::Type ctype)
 {
     switch (ctype) {
-    case WebThemeControlDRT::UncheckedBoxType:
-    case WebThemeControlDRT::CheckedBoxType:
-    case WebThemeControlDRT::UncheckedRadioType:
-    case WebThemeControlDRT::CheckedRadioType: {
+    case WebThemeControlDRTWin::UncheckedBoxType:
+    case WebThemeControlDRTWin::CheckedBoxType:
+    case WebThemeControlDRTWin::UncheckedRadioType:
+    case WebThemeControlDRTWin::CheckedRadioType: {
         SkIRect retval = rect;
 
         // The maximum width and height is 13.
@@ -91,12 +91,12 @@ static SkIRect validate(const SkIRect& rect, WebThemeControlDRT::Type ctype)
     }
 }
 
-// WebThemeControlDRT
+// WebThemeControlDRTWin
 
-WebThemeControlDRT::WebThemeControlDRT(PlatformCanvas* canvas,
-                                       const SkIRect& irect,
-                                       Type ctype,
-                                       State cstate)
+WebThemeControlDRTWin::WebThemeControlDRTWin(PlatformCanvas* canvas,
+                                             const SkIRect& irect,
+                                             Type ctype,
+                                             State cstate)
     : m_canvas(canvas)
     , m_irect(validate(irect, ctype))
     , m_type(ctype)
@@ -113,11 +113,11 @@ WebThemeControlDRT::WebThemeControlDRT(PlatformCanvas* canvas,
 {
 }
 
-WebThemeControlDRT::~WebThemeControlDRT()
+WebThemeControlDRTWin::~WebThemeControlDRTWin()
 {
 }
 
-void WebThemeControlDRT::box(const SkIRect& rect, SkColor fillColor)
+void WebThemeControlDRTWin::box(const SkIRect& rect, SkColor fillColor)
 {
     SkPaint paint;
 
@@ -130,7 +130,7 @@ void WebThemeControlDRT::box(const SkIRect& rect, SkColor fillColor)
     m_canvas->drawIRect(rect, paint);
 }
 
-void WebThemeControlDRT::line(int x0, int y0, int x1, int y1, SkColor color)
+void WebThemeControlDRTWin::line(int x0, int y0, int x1, int y1, SkColor color)
 {
     SkPaint paint;
     paint.setColor(color);
@@ -139,10 +139,10 @@ void WebThemeControlDRT::line(int x0, int y0, int x1, int y1, SkColor color)
                        paint);
 }
 
-void WebThemeControlDRT::triangle(int x0, int y0,
-                                  int x1, int y1,
-                                  int x2, int y2,
-                                  SkColor color)
+void WebThemeControlDRTWin::triangle(int x0, int y0,
+                                     int x1, int y1,
+                                     int x2, int y2,
+                                     SkColor color)
 {
     SkPath path;
     SkPaint paint;
@@ -161,7 +161,7 @@ void WebThemeControlDRT::triangle(int x0, int y0,
     m_canvas->drawPath(path, paint);
 }
 
-void WebThemeControlDRT::roundRect(SkColor color)
+void WebThemeControlDRTWin::roundRect(SkColor color)
 {
     SkRect rect;
     SkScalar radius = SkIntToScalar(5);
@@ -177,7 +177,7 @@ void WebThemeControlDRT::roundRect(SkColor color)
     m_canvas->drawRoundRect(rect, radius, radius, paint);
 }
 
-void WebThemeControlDRT::oval(SkColor color)
+void WebThemeControlDRTWin::oval(SkColor color)
 {
     SkRect rect;
     SkPaint paint;
@@ -192,7 +192,7 @@ void WebThemeControlDRT::oval(SkColor color)
     m_canvas->drawOval(rect, paint);
 }
 
-void WebThemeControlDRT::circle(SkScalar radius, SkColor color)
+void WebThemeControlDRTWin::circle(SkScalar radius, SkColor color)
 {
     SkScalar cy = SkIntToScalar(m_top  + m_height / 2);
     SkScalar cx = SkIntToScalar(m_left + m_width / 2);
@@ -207,12 +207,12 @@ void WebThemeControlDRT::circle(SkScalar radius, SkColor color)
     m_canvas->drawCircle(cx, cy, radius, paint);
 }
 
-void WebThemeControlDRT::nestedBoxes(int indentLeft,
-                                     int indentTop,
-                                     int indentRight,
-                                     int indentBottom,
-                                     SkColor outerColor,
-                                     SkColor innerColor)
+void WebThemeControlDRTWin::nestedBoxes(int indentLeft,
+                                        int indentTop,
+                                        int indentRight,
+                                        int indentBottom,
+                                        SkColor outerColor,
+                                        SkColor innerColor)
 {
     SkIRect lirect;
     box(m_irect, outerColor);
@@ -223,7 +223,7 @@ void WebThemeControlDRT::nestedBoxes(int indentLeft,
     box(lirect, innerColor);
 }
 
-void WebThemeControlDRT::markState()
+void WebThemeControlDRTWin::markState()
 {
     // The horizontal lines in a read only control are spaced by this amount.
     const int readOnlyLineOffset = 5;
@@ -278,7 +278,7 @@ void WebThemeControlDRT::markState()
     }
 }
 
-void WebThemeControlDRT::draw()
+void WebThemeControlDRTWin::draw()
 {
     int halfWidth = m_width / 2;
     int halfHeight = m_height / 2;
@@ -481,7 +481,7 @@ void WebThemeControlDRT::draw()
 // Because rendering a text field is dependent on input
 // parameters the other controls don't have, we render it directly
 // rather than trying to overcomplicate draw() further.
-void WebThemeControlDRT::drawTextField(bool drawEdges, bool fillContentArea, SkColor color)
+void WebThemeControlDRTWin::drawTextField(bool drawEdges, bool fillContentArea, SkColor color)
 {
     SkPaint paint;
 
@@ -501,7 +501,7 @@ void WebThemeControlDRT::drawTextField(bool drawEdges, bool fillContentArea, SkC
     m_canvas->endPlatformPaint();
 }
 
-void WebThemeControlDRT::drawProgressBar(const SkIRect& fillRect)
+void WebThemeControlDRTWin::drawProgressBar(const SkIRect& fillRect)
 {
     SkPaint paint;
 
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-// WebThemeControlDRT implements the generic rendering of controls
-// needed by WebThemeEngineDRT. See the comments in that class
+// WebThemeControlDRTWin implements the generic rendering of controls
+// needed by WebThemeEngineDRTWin. See the comments in that class
 // header file for why this class is needed and used.
 //
 // This class implements a generic set of widgets using Skia. The widgets
 // are optimized for testability, not a pleasing appearance.
 //
 
-#ifndef WebThemeControlDRT_h
-#define WebThemeControlDRT_h
+#ifndef WebThemeControlDRTWin_h
+#define WebThemeControlDRTWin_h
 
 #include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/core/SkColor.h"
@@ -46,7 +46,7 @@
 // Skia forward declarations
 struct SkIRect;
 
-class WebThemeControlDRT : public Noncopyable {
+class WebThemeControlDRTWin : public Noncopyable {
 public:
     // This list of states mostly mirrors the list in WebCore/platform/ThemeTypes.h
     // but is maintained separately since that isn't public and also to minimize
@@ -121,11 +121,11 @@ public:
 
     // canvas is the canvas to draw onto, and rect gives the size of the
     // control. ctype and cstate specify the type and state of the control.
-    WebThemeControlDRT(skia::PlatformCanvas* canvas,
-                       const SkIRect& rect,
-                       Type ctype,
-                       State cstate);
-    ~WebThemeControlDRT();
+    WebThemeControlDRTWin(skia::PlatformCanvas* canvas,
+                          const SkIRect& rect,
+                          Type ctype,
+                          State cstate);
+    ~WebThemeControlDRTWin();
 
     // Draws the control.
     void draw();
@@ -200,4 +200,4 @@ private:
     const int m_height;
 };
 
-#endif // WebThemeControlDRT_h
+#endif // WebThemeControlDRTWin_h
  */
 
 #include "config.h"
-#include "WebThemeEngineDRT.h"
+#include "WebThemeEngineDRTWin.h"
 
 #include "WebRect.h"
-#include "WebThemeControlDRT.h"
+#include "WebThemeControlDRTWin.h"
 #include "third_party/skia/include/core/SkRect.h"
 
 // Although all this code is generic, we include these headers
@@ -57,120 +57,120 @@ static SkIRect webRectToSkIRect(const WebRect& webRect)
 
 static void drawControl(WebCanvas* canvas,
                         const WebRect& rect,
-                        WebThemeControlDRT::Type ctype,
-                        WebThemeControlDRT::State cstate)
+                        WebThemeControlDRTWin::Type ctype,
+                        WebThemeControlDRTWin::State cstate)
 {
-    WebThemeControlDRT control(canvas, webRectToSkIRect(rect), ctype, cstate);
+    WebThemeControlDRTWin control(canvas, webRectToSkIRect(rect), ctype, cstate);
     control.draw();
 }
 
 static void drawTextField(WebCanvas* canvas,
                           const WebRect& rect,
-                          WebThemeControlDRT::Type ctype,
-                          WebThemeControlDRT::State cstate,
+                          WebThemeControlDRTWin::Type ctype,
+                          WebThemeControlDRTWin::State cstate,
                           bool drawEdges,
                           bool fillContentArea,
                           WebColor color)
 {
-    WebThemeControlDRT control(canvas, webRectToSkIRect(rect), ctype, cstate);
+    WebThemeControlDRTWin control(canvas, webRectToSkIRect(rect), ctype, cstate);
     control.drawTextField(drawEdges, fillContentArea, color);
 }
 
 static void drawProgressBar(WebCanvas* canvas,
-                            WebThemeControlDRT::Type ctype,
-                            WebThemeControlDRT::State cstate,
+                            WebThemeControlDRTWin::Type ctype,
+                            WebThemeControlDRTWin::State cstate,
                             const WebRect& barRect,
                             const WebRect& fillRect)
 {
-    WebThemeControlDRT control(canvas, webRectToSkIRect(barRect), ctype, cstate);
+    WebThemeControlDRTWin control(canvas, webRectToSkIRect(barRect), ctype, cstate);
     control.drawProgressBar(webRectToSkIRect(fillRect));
 }
 
-// WebThemeEngineDRT
+// WebThemeEngineDRTWin
 
-void WebThemeEngineDRT::paintButton(WebCanvas* canvas,
-                                    int part,
-                                    int state,
-                                    int classicState,
-                                    const WebRect& rect)
+void WebThemeEngineDRTWin::paintButton(WebCanvas* canvas,
+                                       int part,
+                                       int state,
+                                       int classicState,
+                                       const WebRect& rect)
 {
-    WebThemeControlDRT::Type ctype = WebThemeControlDRT::UnknownType;
-    WebThemeControlDRT::State cstate = WebThemeControlDRT::UnknownState;
+    WebThemeControlDRTWin::Type ctype = WebThemeControlDRTWin::UnknownType;
+    WebThemeControlDRTWin::State cstate = WebThemeControlDRTWin::UnknownState;
 
     if (part == BP_CHECKBOX) {
         switch (state) {
         case CBS_UNCHECKEDNORMAL:
             ASSERT(classicState == dfcsNormal);
-            ctype = WebThemeControlDRT::UncheckedBoxType;
-            cstate = WebThemeControlDRT::NormalState;
+            ctype = WebThemeControlDRTWin::UncheckedBoxType;
+            cstate = WebThemeControlDRTWin::NormalState;
             break;
 
         case CBS_UNCHECKEDHOT:
             ASSERT(classicState == (DFCS_BUTTONCHECK | DFCS_HOT));
-            ctype = WebThemeControlDRT::UncheckedBoxType;
-            cstate = WebThemeControlDRT::HotState;
+            ctype = WebThemeControlDRTWin::UncheckedBoxType;
+            cstate = WebThemeControlDRTWin::HotState;
             break;
 
         case CBS_UNCHECKEDPRESSED:
             ASSERT(classicState == (DFCS_BUTTONCHECK | DFCS_PUSHED));
-            ctype = WebThemeControlDRT::UncheckedBoxType;
-            cstate = WebThemeControlDRT::PressedState;
+            ctype = WebThemeControlDRTWin::UncheckedBoxType;
+            cstate = WebThemeControlDRTWin::PressedState;
             break;
 
         case CBS_UNCHECKEDDISABLED:
             ASSERT(classicState == (DFCS_BUTTONCHECK | DFCS_INACTIVE));
-            ctype = WebThemeControlDRT::UncheckedBoxType;
-            cstate = WebThemeControlDRT::DisabledState;
+            ctype = WebThemeControlDRTWin::UncheckedBoxType;
+            cstate = WebThemeControlDRTWin::DisabledState;
             break;
 
         case CBS_CHECKEDNORMAL:
             ASSERT(classicState == (DFCS_BUTTONCHECK | DFCS_CHECKED));
-            ctype = WebThemeControlDRT::CheckedBoxType;
-            cstate = WebThemeControlDRT::NormalState;
+            ctype = WebThemeControlDRTWin::CheckedBoxType;
+            cstate = WebThemeControlDRTWin::NormalState;
             break;
 
         case CBS_CHECKEDHOT:
             ASSERT(classicState == (DFCS_BUTTONCHECK | DFCS_CHECKED | DFCS_HOT));
-            ctype = WebThemeControlDRT::CheckedBoxType;
-            cstate = WebThemeControlDRT::HotState;
+            ctype = WebThemeControlDRTWin::CheckedBoxType;
+            cstate = WebThemeControlDRTWin::HotState;
             break;
 
         case CBS_CHECKEDPRESSED:
             ASSERT(classicState == (DFCS_BUTTONCHECK | DFCS_CHECKED | DFCS_PUSHED));
-            ctype = WebThemeControlDRT::CheckedBoxType;
-            cstate = WebThemeControlDRT::PressedState;
+            ctype = WebThemeControlDRTWin::CheckedBoxType;
+            cstate = WebThemeControlDRTWin::PressedState;
             break;
 
         case CBS_CHECKEDDISABLED:
             ASSERT(classicState == (DFCS_BUTTONCHECK | DFCS_CHECKED | DFCS_INACTIVE));
-            ctype = WebThemeControlDRT::CheckedBoxType;
-            cstate = WebThemeControlDRT::DisabledState;
+            ctype = WebThemeControlDRTWin::CheckedBoxType;
+            cstate = WebThemeControlDRTWin::DisabledState;
             break;
 
         case CBS_MIXEDNORMAL:
             // Classic theme can't represent mixed state checkbox. We assume
             // it's equivalent to unchecked.
             ASSERT(classicState == DFCS_BUTTONCHECK);
-            ctype = WebThemeControlDRT::IndeterminateCheckboxType;
-            cstate = WebThemeControlDRT::NormalState;
+            ctype = WebThemeControlDRTWin::IndeterminateCheckboxType;
+            cstate = WebThemeControlDRTWin::NormalState;
             break;
 
         case CBS_MIXEDHOT:
             ASSERT(classicState == (DFCS_BUTTONCHECK | DFCS_HOT));
-            ctype = WebThemeControlDRT::IndeterminateCheckboxType;
-            cstate = WebThemeControlDRT::HotState;
+            ctype = WebThemeControlDRTWin::IndeterminateCheckboxType;
+            cstate = WebThemeControlDRTWin::HotState;
             break;
 
         case CBS_MIXEDPRESSED:
             ASSERT(classicState == (DFCS_BUTTONCHECK | DFCS_PUSHED));
-            ctype = WebThemeControlDRT::IndeterminateCheckboxType;
-            cstate = WebThemeControlDRT::PressedState;
+            ctype = WebThemeControlDRTWin::IndeterminateCheckboxType;
+            cstate = WebThemeControlDRTWin::PressedState;
             break;
 
         case CBS_MIXEDDISABLED:
             ASSERT(classicState == (DFCS_BUTTONCHECK | DFCS_INACTIVE));
-            ctype = WebThemeControlDRT::IndeterminateCheckboxType;
-            cstate = WebThemeControlDRT::DisabledState;
+            ctype = WebThemeControlDRTWin::IndeterminateCheckboxType;
+            cstate = WebThemeControlDRTWin::DisabledState;
             break;
 
         default:
@@ -181,50 +181,50 @@ void WebThemeEngineDRT::paintButton(WebCanvas* canvas,
         switch (state) {
         case RBS_UNCHECKEDNORMAL:
             ASSERT(classicState == DFCS_BUTTONRADIO);
-            ctype = WebThemeControlDRT::UncheckedRadioType;
-            cstate = WebThemeControlDRT::NormalState;
+            ctype = WebThemeControlDRTWin::UncheckedRadioType;
+            cstate = WebThemeControlDRTWin::NormalState;
             break;
 
         case RBS_UNCHECKEDHOT:
             ASSERT(classicState == (DFCS_BUTTONRADIO | DFCS_HOT));
-            ctype = WebThemeControlDRT::UncheckedRadioType;
-            cstate = WebThemeControlDRT::HotState;
+            ctype = WebThemeControlDRTWin::UncheckedRadioType;
+            cstate = WebThemeControlDRTWin::HotState;
             break;
 
         case RBS_UNCHECKEDPRESSED:
             ASSERT(classicState == (DFCS_BUTTONRADIO | DFCS_PUSHED));
-            ctype = WebThemeControlDRT::UncheckedRadioType;
-            cstate = WebThemeControlDRT::PressedState;
+            ctype = WebThemeControlDRTWin::UncheckedRadioType;
+            cstate = WebThemeControlDRTWin::PressedState;
             break;
 
         case RBS_UNCHECKEDDISABLED:
             ASSERT(classicState == (DFCS_BUTTONRADIO | DFCS_INACTIVE));
-            ctype = WebThemeControlDRT::UncheckedRadioType;
-            cstate = WebThemeControlDRT::DisabledState;
+            ctype = WebThemeControlDRTWin::UncheckedRadioType;
+            cstate = WebThemeControlDRTWin::DisabledState;
             break;
 
         case RBS_CHECKEDNORMAL:
             ASSERT(classicState == (DFCS_BUTTONRADIO | DFCS_CHECKED));
-            ctype = WebThemeControlDRT::CheckedRadioType;
-            cstate = WebThemeControlDRT::NormalState;
+            ctype = WebThemeControlDRTWin::CheckedRadioType;
+            cstate = WebThemeControlDRTWin::NormalState;
             break;
 
         case RBS_CHECKEDHOT:
             ASSERT(classicState == (DFCS_BUTTONRADIO | DFCS_CHECKED | DFCS_HOT));
-            ctype = WebThemeControlDRT::CheckedRadioType;
-            cstate = WebThemeControlDRT::HotState;
+            ctype = WebThemeControlDRTWin::CheckedRadioType;
+            cstate = WebThemeControlDRTWin::HotState;
             break;
 
         case RBS_CHECKEDPRESSED:
             ASSERT(classicState == (DFCS_BUTTONRADIO | DFCS_CHECKED | DFCS_PUSHED));
-            ctype = WebThemeControlDRT::CheckedRadioType;
-            cstate = WebThemeControlDRT::PressedState;
+            ctype = WebThemeControlDRTWin::CheckedRadioType;
+            cstate = WebThemeControlDRTWin::PressedState;
             break;
 
         case RBS_CHECKEDDISABLED:
             ASSERT(classicState == (DFCS_BUTTONRADIO | DFCS_CHECKED | DFCS_INACTIVE));
-            ctype = WebThemeControlDRT::CheckedRadioType;
-            cstate = WebThemeControlDRT::DisabledState;
+            ctype = WebThemeControlDRTWin::CheckedRadioType;
+            cstate = WebThemeControlDRTWin::DisabledState;
             break;
 
         default:
@@ -235,32 +235,32 @@ void WebThemeEngineDRT::paintButton(WebCanvas* canvas,
         switch (state) {
         case PBS_NORMAL:
             ASSERT(classicState == DFCS_BUTTONPUSH);
-            ctype = WebThemeControlDRT::PushButtonType;
-            cstate = WebThemeControlDRT::NormalState;
+            ctype = WebThemeControlDRTWin::PushButtonType;
+            cstate = WebThemeControlDRTWin::NormalState;
             break;
 
         case PBS_HOT:
             ASSERT(classicState == (DFCS_BUTTONPUSH | DFCS_HOT));
-            ctype = WebThemeControlDRT::PushButtonType;
-            cstate = WebThemeControlDRT::HotState;
+            ctype = WebThemeControlDRTWin::PushButtonType;
+            cstate = WebThemeControlDRTWin::HotState;
             break;
 
         case PBS_PRESSED:
             ASSERT(classicState == (DFCS_BUTTONPUSH | DFCS_PUSHED));
-            ctype = WebThemeControlDRT::PushButtonType;
-            cstate = WebThemeControlDRT::PressedState;
+            ctype = WebThemeControlDRTWin::PushButtonType;
+            cstate = WebThemeControlDRTWin::PressedState;
             break;
 
         case PBS_DISABLED:
             ASSERT(classicState == (DFCS_BUTTONPUSH | DFCS_INACTIVE));
-            ctype = WebThemeControlDRT::PushButtonType;
-            cstate = WebThemeControlDRT::DisabledState;
+            ctype = WebThemeControlDRTWin::PushButtonType;
+            cstate = WebThemeControlDRTWin::DisabledState;
             break;
 
         case PBS_DEFAULTED:
             ASSERT(classicState == DFCS_BUTTONPUSH);
-            ctype = WebThemeControlDRT::PushButtonType;
-            cstate = WebThemeControlDRT::FocusedState;
+            ctype = WebThemeControlDRTWin::PushButtonType;
+            cstate = WebThemeControlDRTWin::FocusedState;
             break;
 
         default:
@@ -275,36 +275,36 @@ void WebThemeEngineDRT::paintButton(WebCanvas* canvas,
 }
 
 
-void WebThemeEngineDRT::paintMenuList(WebCanvas* canvas,
-                                      int part,
-                                      int state,
-                                      int classicState,
-                                      const WebRect& rect)
+void WebThemeEngineDRTWin::paintMenuList(WebCanvas* canvas,
+                                         int part,
+                                         int state,
+                                         int classicState,
+                                         const WebRect& rect)
 {
-    WebThemeControlDRT::Type ctype = WebThemeControlDRT::UnknownType;
-    WebThemeControlDRT::State cstate = WebThemeControlDRT::UnknownState;
+    WebThemeControlDRTWin::Type ctype = WebThemeControlDRTWin::UnknownType;
+    WebThemeControlDRTWin::State cstate = WebThemeControlDRTWin::UnknownState;
 
     if (CP_DROPDOWNBUTTON == part) {
-        ctype = WebThemeControlDRT::DropDownButtonType;
+        ctype = WebThemeControlDRTWin::DropDownButtonType;
         switch (state) {
         case CBXS_NORMAL:
             ASSERT(classicState == DFCS_MENUARROW);
-            cstate = WebThemeControlDRT::NormalState;
+            cstate = WebThemeControlDRTWin::NormalState;
             break;
 
         case CBXS_HOT:
             ASSERT(classicState == (DFCS_MENUARROW | DFCS_HOT));
-            cstate = WebThemeControlDRT::HoverState;
+            cstate = WebThemeControlDRTWin::HoverState;
             break;
 
         case CBXS_PRESSED:
             ASSERT(classicState == (DFCS_MENUARROW | DFCS_PUSHED));
-            cstate = WebThemeControlDRT::PressedState;
+            cstate = WebThemeControlDRTWin::PressedState;
             break;
 
         case CBXS_DISABLED:
             ASSERT(classicState == (DFCS_MENUARROW | DFCS_INACTIVE));
-            cstate = WebThemeControlDRT::DisabledState;
+            cstate = WebThemeControlDRTWin::DisabledState;
             break;
 
         default:
@@ -318,133 +318,133 @@ void WebThemeEngineDRT::paintMenuList(WebCanvas* canvas,
     drawControl(canvas, rect, ctype, cstate);
 }
 
-void WebThemeEngineDRT::paintScrollbarArrow(WebCanvas* canvas,
-                                            int state,
-                                            int classicState,
-                                            const WebRect& rect)
+void WebThemeEngineDRTWin::paintScrollbarArrow(WebCanvas* canvas,
+                                               int state,
+                                               int classicState,
+                                               const WebRect& rect)
 {
-    WebThemeControlDRT::Type ctype = WebThemeControlDRT::UnknownType;
-    WebThemeControlDRT::State cstate = WebThemeControlDRT::UnknownState;
+    WebThemeControlDRTWin::Type ctype = WebThemeControlDRTWin::UnknownType;
+    WebThemeControlDRTWin::State cstate = WebThemeControlDRTWin::UnknownState;
 
     switch (state) {
     case ABS_UPNORMAL:
         ASSERT(classicState == DFCS_SCROLLUP);
-        ctype = WebThemeControlDRT::UpArrowType;
-        cstate = WebThemeControlDRT::NormalState;
+        ctype = WebThemeControlDRTWin::UpArrowType;
+        cstate = WebThemeControlDRTWin::NormalState;
         break;
 
     case ABS_DOWNNORMAL:
         ASSERT(classicState == DFCS_SCROLLDOWN);
-        ctype = WebThemeControlDRT::DownArrowType;
-        cstate = WebThemeControlDRT::NormalState;
+        ctype = WebThemeControlDRTWin::DownArrowType;
+        cstate = WebThemeControlDRTWin::NormalState;
         break;
 
     case ABS_LEFTNORMAL:
         ASSERT(classicState == DFCS_SCROLLLEFT);
-        ctype = WebThemeControlDRT::LeftArrowType;
-        cstate = WebThemeControlDRT::NormalState;
+        ctype = WebThemeControlDRTWin::LeftArrowType;
+        cstate = WebThemeControlDRTWin::NormalState;
         break;
 
     case ABS_RIGHTNORMAL:
         ASSERT(classicState == DFCS_SCROLLRIGHT);
-        ctype = WebThemeControlDRT::RightArrowType;
-        cstate = WebThemeControlDRT::NormalState;
+        ctype = WebThemeControlDRTWin::RightArrowType;
+        cstate = WebThemeControlDRTWin::NormalState;
         break;
 
     case ABS_UPHOT:
         ASSERT(classicState == (DFCS_SCROLLUP | DFCS_HOT));
-        ctype = WebThemeControlDRT::UpArrowType;
-        cstate = WebThemeControlDRT::HotState;
+        ctype = WebThemeControlDRTWin::UpArrowType;
+        cstate = WebThemeControlDRTWin::HotState;
         break;
 
     case ABS_DOWNHOT:
         ASSERT(classicState == (DFCS_SCROLLDOWN | DFCS_HOT));
-        ctype = WebThemeControlDRT::DownArrowType;
-        cstate = WebThemeControlDRT::HotState;
+        ctype = WebThemeControlDRTWin::DownArrowType;
+        cstate = WebThemeControlDRTWin::HotState;
         break;
 
     case ABS_LEFTHOT:
         ASSERT(classicState == (DFCS_SCROLLLEFT | DFCS_HOT));
-        ctype = WebThemeControlDRT::LeftArrowType;
-        cstate = WebThemeControlDRT::HotState;
+        ctype = WebThemeControlDRTWin::LeftArrowType;
+        cstate = WebThemeControlDRTWin::HotState;
         break;
 
     case ABS_RIGHTHOT:
         ASSERT(classicState == (DFCS_SCROLLRIGHT | DFCS_HOT));
-        ctype = WebThemeControlDRT::RightArrowType;
-        cstate = WebThemeControlDRT::HotState;
+        ctype = WebThemeControlDRTWin::RightArrowType;
+        cstate = WebThemeControlDRTWin::HotState;
         break;
 
     case ABS_UPHOVER:
         ASSERT(classicState == DFCS_SCROLLUP);
-        ctype = WebThemeControlDRT::UpArrowType;
-        cstate = WebThemeControlDRT::HoverState;
+        ctype = WebThemeControlDRTWin::UpArrowType;
+        cstate = WebThemeControlDRTWin::HoverState;
         break;
 
     case ABS_DOWNHOVER:
         ASSERT(classicState == DFCS_SCROLLDOWN);
-        ctype = WebThemeControlDRT::DownArrowType;
-        cstate = WebThemeControlDRT::HoverState;
+        ctype = WebThemeControlDRTWin::DownArrowType;
+        cstate = WebThemeControlDRTWin::HoverState;
         break;
 
     case ABS_LEFTHOVER:
         ASSERT(classicState == DFCS_SCROLLLEFT);
-        ctype = WebThemeControlDRT::LeftArrowType;
-        cstate = WebThemeControlDRT::HoverState;
+        ctype = WebThemeControlDRTWin::LeftArrowType;
+        cstate = WebThemeControlDRTWin::HoverState;
         break;
 
     case ABS_RIGHTHOVER:
         ASSERT(classicState == DFCS_SCROLLRIGHT);
-        ctype = WebThemeControlDRT::RightArrowType;
-        cstate = WebThemeControlDRT::HoverState;
+        ctype = WebThemeControlDRTWin::RightArrowType;
+        cstate = WebThemeControlDRTWin::HoverState;
         break;
 
     case ABS_UPPRESSED:
         ASSERT(classicState == (DFCS_SCROLLUP | DFCS_PUSHED | DFCS_FLAT));
-        ctype = WebThemeControlDRT::UpArrowType;
-        cstate = WebThemeControlDRT::PressedState;
+        ctype = WebThemeControlDRTWin::UpArrowType;
+        cstate = WebThemeControlDRTWin::PressedState;
         break;
 
     case ABS_DOWNPRESSED:
         ASSERT(classicState == (DFCS_SCROLLDOWN | DFCS_PUSHED | DFCS_FLAT));
-        ctype = WebThemeControlDRT::DownArrowType;
-        cstate = WebThemeControlDRT::PressedState;
+        ctype = WebThemeControlDRTWin::DownArrowType;
+        cstate = WebThemeControlDRTWin::PressedState;
         break;
 
     case ABS_LEFTPRESSED:
         ASSERT(classicState == (DFCS_SCROLLLEFT | DFCS_PUSHED | DFCS_FLAT));
-        ctype = WebThemeControlDRT::LeftArrowType;
-        cstate = WebThemeControlDRT::PressedState;
+        ctype = WebThemeControlDRTWin::LeftArrowType;
+        cstate = WebThemeControlDRTWin::PressedState;
         break;
 
     case ABS_RIGHTPRESSED:
         ASSERT(classicState == (DFCS_SCROLLRIGHT | DFCS_PUSHED | DFCS_FLAT));
-        ctype = WebThemeControlDRT::RightArrowType;
-        cstate = WebThemeControlDRT::PressedState;
+        ctype = WebThemeControlDRTWin::RightArrowType;
+        cstate = WebThemeControlDRTWin::PressedState;
         break;
 
     case ABS_UPDISABLED:
         ASSERT(classicState == (DFCS_SCROLLUP | DFCS_INACTIVE));
-        ctype = WebThemeControlDRT::UpArrowType;
-        cstate = WebThemeControlDRT::DisabledState;
+        ctype = WebThemeControlDRTWin::UpArrowType;
+        cstate = WebThemeControlDRTWin::DisabledState;
         break;
 
     case ABS_DOWNDISABLED:
         ASSERT(classicState == (DFCS_SCROLLDOWN | DFCS_INACTIVE));
-        ctype = WebThemeControlDRT::DownArrowType;
-        cstate = WebThemeControlDRT::DisabledState;
+        ctype = WebThemeControlDRTWin::DownArrowType;
+        cstate = WebThemeControlDRTWin::DisabledState;
         break;
 
     case ABS_LEFTDISABLED:
         ASSERT(classicState == (DFCS_SCROLLLEFT | DFCS_INACTIVE));
-        ctype = WebThemeControlDRT::LeftArrowType;
-        cstate = WebThemeControlDRT::DisabledState;
+        ctype = WebThemeControlDRTWin::LeftArrowType;
+        cstate = WebThemeControlDRTWin::DisabledState;
         break;
 
     case ABS_RIGHTDISABLED:
         ASSERT(classicState == (DFCS_SCROLLRIGHT | DFCS_INACTIVE));
-        ctype = WebThemeControlDRT::RightArrowType;
-        cstate = WebThemeControlDRT::DisabledState;
+        ctype = WebThemeControlDRTWin::RightArrowType;
+        cstate = WebThemeControlDRTWin::DisabledState;
         break;
 
     default:
@@ -455,30 +455,30 @@ void WebThemeEngineDRT::paintScrollbarArrow(WebCanvas* canvas,
     drawControl(canvas, rect, ctype, cstate);
 }
 
-void WebThemeEngineDRT::paintScrollbarThumb(WebCanvas* canvas,
-                                            int part,
-                                            int state,
-                                            int classicState,
-                                            const WebRect& rect)
+void WebThemeEngineDRTWin::paintScrollbarThumb(WebCanvas* canvas,
+                                               int part,
+                                               int state,
+                                               int classicState,
+                                               const WebRect& rect)
 {
-    WebThemeControlDRT::Type ctype = WebThemeControlDRT::UnknownType;
-    WebThemeControlDRT::State cstate = WebThemeControlDRT::UnknownState;
+    WebThemeControlDRTWin::Type ctype = WebThemeControlDRTWin::UnknownType;
+    WebThemeControlDRTWin::State cstate = WebThemeControlDRTWin::UnknownState;
 
     switch (part) {
     case SBP_THUMBBTNHORZ:
-        ctype = WebThemeControlDRT::HorizontalScrollThumbType;
+        ctype = WebThemeControlDRTWin::HorizontalScrollThumbType;
         break;
 
     case SBP_THUMBBTNVERT:
-        ctype = WebThemeControlDRT::VerticalScrollThumbType;
+        ctype = WebThemeControlDRTWin::VerticalScrollThumbType;
         break;
 
     case SBP_GRIPPERHORZ:
-        ctype = WebThemeControlDRT::HorizontalScrollGripType;
+        ctype = WebThemeControlDRTWin::HorizontalScrollGripType;
         break;
 
     case SBP_GRIPPERVERT:
-        ctype = WebThemeControlDRT::VerticalScrollGripType;
+        ctype = WebThemeControlDRTWin::VerticalScrollGripType;
         break;
 
     default:
@@ -489,22 +489,22 @@ void WebThemeEngineDRT::paintScrollbarThumb(WebCanvas* canvas,
     switch (state) {
     case SCRBS_NORMAL:
         ASSERT(classicState == dfcsNormal);
-        cstate = WebThemeControlDRT::NormalState;
+        cstate = WebThemeControlDRTWin::NormalState;
         break;
 
     case SCRBS_HOT:
         ASSERT(classicState == DFCS_HOT);
-        cstate = WebThemeControlDRT::HotState;
+        cstate = WebThemeControlDRTWin::HotState;
         break;
 
     case SCRBS_HOVER:
         ASSERT(classicState == dfcsNormal);
-        cstate = WebThemeControlDRT::HoverState;
+        cstate = WebThemeControlDRTWin::HoverState;
         break;
 
     case SCRBS_PRESSED:
         ASSERT(classicState == dfcsNormal);
-        cstate = WebThemeControlDRT::PressedState;
+        cstate = WebThemeControlDRTWin::PressedState;
         break;
 
     case SCRBS_DISABLED:
@@ -519,31 +519,31 @@ void WebThemeEngineDRT::paintScrollbarThumb(WebCanvas* canvas,
     drawControl(canvas, rect, ctype, cstate);
 }
 
-void WebThemeEngineDRT::paintScrollbarTrack(WebCanvas* canvas,
-                                            int part,
-                                            int state,
-                                            int classicState,
-                                            const WebRect& rect,
-                                            const WebRect& alignRect)
+void WebThemeEngineDRTWin::paintScrollbarTrack(WebCanvas* canvas,
+                                               int part,
+                                               int state,
+                                               int classicState,
+                                               const WebRect& rect,
+                                               const WebRect& alignRect)
 {
-    WebThemeControlDRT::Type ctype = WebThemeControlDRT::UnknownType;
-    WebThemeControlDRT::State cstate = WebThemeControlDRT::UnknownState;
+    WebThemeControlDRTWin::Type ctype = WebThemeControlDRTWin::UnknownType;
+    WebThemeControlDRTWin::State cstate = WebThemeControlDRTWin::UnknownState;
 
     switch (part) {
     case SBP_UPPERTRACKHORZ:
-        ctype = WebThemeControlDRT::HorizontalScrollTrackBackType;
+        ctype = WebThemeControlDRTWin::HorizontalScrollTrackBackType;
         break;
 
     case SBP_LOWERTRACKHORZ:
-        ctype = WebThemeControlDRT::HorizontalScrollTrackForwardType;
+        ctype = WebThemeControlDRTWin::HorizontalScrollTrackForwardType;
         break;
 
     case SBP_UPPERTRACKVERT:
-        ctype = WebThemeControlDRT::VerticalScrollTrackBackType;
+        ctype = WebThemeControlDRTWin::VerticalScrollTrackBackType;
         break;
 
     case SBP_LOWERTRACKVERT:
-        ctype = WebThemeControlDRT::VerticalScrollTrackForwardType;
+        ctype = WebThemeControlDRTWin::VerticalScrollTrackForwardType;
         break;
 
     default:
@@ -554,7 +554,7 @@ void WebThemeEngineDRT::paintScrollbarTrack(WebCanvas* canvas,
     switch (state) {
     case SCRBS_NORMAL:
         ASSERT(classicState == dfcsNormal);
-        cstate = WebThemeControlDRT::NormalState;
+        cstate = WebThemeControlDRTWin::NormalState;
         break;
 
     case SCRBS_HOT:
@@ -563,7 +563,7 @@ void WebThemeEngineDRT::paintScrollbarTrack(WebCanvas* canvas,
 
     case SCRBS_HOVER:
         ASSERT(classicState == dfcsNormal);
-        cstate = WebThemeControlDRT::HoverState;
+        cstate = WebThemeControlDRTWin::HoverState;
         break;
 
     case SCRBS_PRESSED:
@@ -572,7 +572,7 @@ void WebThemeEngineDRT::paintScrollbarTrack(WebCanvas* canvas,
 
     case SCRBS_DISABLED:
         ASSERT(classicState == DFCS_INACTIVE);
-        cstate = WebThemeControlDRT::DisabledState;
+        cstate = WebThemeControlDRTWin::DisabledState;
         break;
 
     default:
@@ -583,55 +583,55 @@ void WebThemeEngineDRT::paintScrollbarTrack(WebCanvas* canvas,
     drawControl(canvas, rect, ctype, cstate);
 }
 
-void WebThemeEngineDRT::paintSpinButton(WebCanvas* canvas,
-                                        int part,
-                                        int state,
-                                        int classicState,
-                                        const WebRect& rect)
+void WebThemeEngineDRTWin::paintSpinButton(WebCanvas* canvas,
+                                           int part,
+                                           int state,
+                                           int classicState,
+                                           const WebRect& rect)
 {
-    WebThemeControlDRT::Type ctype = WebThemeControlDRT::UnknownType;
-    WebThemeControlDRT::State cstate = WebThemeControlDRT::UnknownState;
+    WebThemeControlDRTWin::Type ctype = WebThemeControlDRTWin::UnknownType;
+    WebThemeControlDRTWin::State cstate = WebThemeControlDRTWin::UnknownState;
 
     if (part == SPNP_UP) {
-        ctype = WebThemeControlDRT::UpArrowType;
+        ctype = WebThemeControlDRTWin::UpArrowType;
         switch (state) {
         case UPS_NORMAL:
             ASSERT(classicState == DFCS_SCROLLUP);
-            cstate = WebThemeControlDRT::NormalState;
+            cstate = WebThemeControlDRTWin::NormalState;
             break;
         case UPS_DISABLED:
             ASSERT(classicState == (DFCS_SCROLLUP | DFCS_INACTIVE));
-            cstate = WebThemeControlDRT::DisabledState;
+            cstate = WebThemeControlDRTWin::DisabledState;
             break;
         case UPS_PRESSED:
             ASSERT(classicState == (DFCS_SCROLLUP | DFCS_PUSHED));
-            cstate = WebThemeControlDRT::PressedState;
+            cstate = WebThemeControlDRTWin::PressedState;
             break;
         case UPS_HOT:
             ASSERT(classicState == (DFCS_SCROLLUP | DFCS_HOT));
-            cstate = WebThemeControlDRT::HoverState;
+            cstate = WebThemeControlDRTWin::HoverState;
             break;
         default:
             ASSERT_NOT_REACHED();
         }
     } else if (part == SPNP_DOWN) {
-        ctype = WebThemeControlDRT::DownArrowType;
+        ctype = WebThemeControlDRTWin::DownArrowType;
         switch (state) {
         case DNS_NORMAL:
             ASSERT(classicState == DFCS_SCROLLDOWN);
-            cstate = WebThemeControlDRT::NormalState;
+            cstate = WebThemeControlDRTWin::NormalState;
             break;
         case DNS_DISABLED:
             ASSERT(classicState == (DFCS_SCROLLDOWN | DFCS_INACTIVE));
-            cstate = WebThemeControlDRT::DisabledState;
+            cstate = WebThemeControlDRTWin::DisabledState;
             break;
         case DNS_PRESSED:
             ASSERT(classicState == (DFCS_SCROLLDOWN | DFCS_PUSHED));
-            cstate = WebThemeControlDRT::PressedState;
+            cstate = WebThemeControlDRTWin::PressedState;
             break;
         case DNS_HOT:
             ASSERT(classicState == (DFCS_SCROLLDOWN | DFCS_HOT));
-            cstate = WebThemeControlDRT::HoverState;
+            cstate = WebThemeControlDRTWin::HoverState;
             break;
         default:
             ASSERT_NOT_REACHED();
@@ -641,50 +641,50 @@ void WebThemeEngineDRT::paintSpinButton(WebCanvas* canvas,
     drawControl(canvas, rect, ctype, cstate);
 }
 
-void WebThemeEngineDRT::paintTextField(WebCanvas* canvas,
-                                       int part,
-                                       int state,
-                                       int classicState,
-                                       const WebRect& rect,
-                                       WebColor color,
-                                       bool fillContentArea,
-                                       bool drawEdges)
+void WebThemeEngineDRTWin::paintTextField(WebCanvas* canvas,
+                                          int part,
+                                          int state,
+                                          int classicState,
+                                          const WebRect& rect,
+                                          WebColor color,
+                                          bool fillContentArea,
+                                          bool drawEdges)
 {
-    WebThemeControlDRT::Type ctype = WebThemeControlDRT::UnknownType;
-    WebThemeControlDRT::State cstate = WebThemeControlDRT::UnknownState;
+    WebThemeControlDRTWin::Type ctype = WebThemeControlDRTWin::UnknownType;
+    WebThemeControlDRTWin::State cstate = WebThemeControlDRTWin::UnknownState;
 
     ASSERT(EP_EDITTEXT == part);
-    ctype = WebThemeControlDRT::TextFieldType;
+    ctype = WebThemeControlDRTWin::TextFieldType;
 
     switch (state) {
     case ETS_NORMAL:
         ASSERT(classicState == dfcsNormal);
-        cstate = WebThemeControlDRT::NormalState;
+        cstate = WebThemeControlDRTWin::NormalState;
         break;
 
     case ETS_HOT:
         ASSERT(classicState == DFCS_HOT);
-        cstate = WebThemeControlDRT::HotState;
+        cstate = WebThemeControlDRTWin::HotState;
         break;
 
     case ETS_DISABLED:
         ASSERT(classicState == DFCS_INACTIVE);
-        cstate = WebThemeControlDRT::DisabledState;
+        cstate = WebThemeControlDRTWin::DisabledState;
         break;
 
     case ETS_SELECTED:
         ASSERT(classicState == DFCS_PUSHED);
-        cstate = WebThemeControlDRT::PressedState;
+        cstate = WebThemeControlDRTWin::PressedState;
         break;
 
     case ETS_FOCUSED:
         ASSERT(classicState == dfcsNormal);
-        cstate = WebThemeControlDRT::FocusedState;
+        cstate = WebThemeControlDRTWin::FocusedState;
         break;
 
     case ETS_READONLY:
         ASSERT(classicState == dfcsNormal);
-        cstate = WebThemeControlDRT::ReadOnlyState;
+        cstate = WebThemeControlDRTWin::ReadOnlyState;
         break;
 
     default:
@@ -695,36 +695,36 @@ void WebThemeEngineDRT::paintTextField(WebCanvas* canvas,
     drawTextField(canvas, rect, ctype, cstate, drawEdges, fillContentArea, color);
 }
 
-void WebThemeEngineDRT::paintTrackbar(WebCanvas* canvas,
-                                      int part,
-                                      int state,
-                                      int classicState,
-                                      const WebRect& rect)
+void WebThemeEngineDRTWin::paintTrackbar(WebCanvas* canvas,
+                                         int part,
+                                         int state,
+                                         int classicState,
+                                         const WebRect& rect)
 {
-    WebThemeControlDRT::Type ctype = WebThemeControlDRT::UnknownType;
-    WebThemeControlDRT::State cstate = WebThemeControlDRT::UnknownState;
+    WebThemeControlDRTWin::Type ctype = WebThemeControlDRTWin::UnknownType;
+    WebThemeControlDRTWin::State cstate = WebThemeControlDRTWin::UnknownState;
 
     if (TKP_THUMBBOTTOM == part) {
-        ctype = WebThemeControlDRT::HorizontalSliderThumbType;
+        ctype = WebThemeControlDRTWin::HorizontalSliderThumbType;
         switch (state) {
         case TUS_NORMAL:
             ASSERT(classicState == dfcsNormal);
-            cstate = WebThemeControlDRT::NormalState;
+            cstate = WebThemeControlDRTWin::NormalState;
             break;
 
         case TUS_HOT:
             ASSERT(classicState == DFCS_HOT);
-            cstate = WebThemeControlDRT::HotState;
+            cstate = WebThemeControlDRTWin::HotState;
             break;
 
         case TUS_DISABLED:
             ASSERT(classicState == DFCS_INACTIVE);
-            cstate = WebThemeControlDRT::DisabledState;
+            cstate = WebThemeControlDRTWin::DisabledState;
             break;
 
         case TUS_PRESSED:
             ASSERT(classicState == DFCS_PUSHED);
-            cstate = WebThemeControlDRT::PressedState;
+            cstate = WebThemeControlDRTWin::PressedState;
             break;
 
         default:
@@ -732,10 +732,10 @@ void WebThemeEngineDRT::paintTrackbar(WebCanvas* canvas,
             break;
         }
     } else if (TKP_TRACK == part) {
-        ctype = WebThemeControlDRT::HorizontalSliderTrackType;
+        ctype = WebThemeControlDRTWin::HorizontalSliderTrackType;
         ASSERT(part == TUS_NORMAL);
         ASSERT(classicState == dfcsNormal);
-        cstate = WebThemeControlDRT::NormalState;
+        cstate = WebThemeControlDRTWin::NormalState;
     } else {
         ASSERT_NOT_REACHED();
     }
@@ -744,15 +744,15 @@ void WebThemeEngineDRT::paintTrackbar(WebCanvas* canvas,
 }
 
 
-void WebThemeEngineDRT::paintProgressBar(WebKit::WebCanvas* canvas,
-                                         const WebKit::WebRect& barRect,
-                                         const WebKit::WebRect& valueRect,
-                                         bool determinate,
-                                         double)
+void WebThemeEngineDRTWin::paintProgressBar(WebKit::WebCanvas* canvas,
+                                            const WebKit::WebRect& barRect,
+                                            const WebKit::WebRect& valueRect,
+                                            bool determinate,
+                                            double)
 {
-    WebThemeControlDRT::Type ctype = WebThemeControlDRT::ProgressBarType;
-    WebThemeControlDRT::State cstate = determinate ? WebThemeControlDRT::NormalState 
-                                                   : WebThemeControlDRT::IndeterminateState;
+    WebThemeControlDRTWin::Type ctype = WebThemeControlDRTWin::ProgressBarType;
+    WebThemeControlDRTWin::State cstate = determinate ? WebThemeControlDRTWin::NormalState
+                                                      : WebThemeControlDRTWin::IndeterminateState;
     drawProgressBar(canvas, ctype, cstate, barRect, valueRect);
 }
 
 // choose to do so at some point.
 //
 
-#ifndef WebThemeEngineDRT_h
-#define WebThemeEngineDRT_h
+#ifndef WebThemeEngineDRTWin_h
+#define WebThemeEngineDRTWin_h
 
 #include "win/WebThemeEngine.h"
 #include <wtf/Noncopyable.h>
 
-class WebThemeEngineDRT : public WebKit::WebThemeEngine, public Noncopyable {
+class WebThemeEngineDRTWin : public WebKit::WebThemeEngine, public Noncopyable {
 public:
-    WebThemeEngineDRT() {}
+    WebThemeEngineDRTWin() {}
 
     // WebThemeEngine methods:
     virtual void paintButton(
@@ -94,4 +94,4 @@ public:
         bool determinate, double time);
 };
 
-#endif // WebThemeEngineDRT_h
+#endif // WebThemeEngineDRTWin_h