ui: Move NativeTheme files into ui/base/native_theme/ directory.

ui/base/native_theme/native_theme_win.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/gfx/native_theme_win.h"
+#include "ui/base/native_theme/native_theme_win.h"
 
 #include <windows.h>
 #include <uxtheme.h>
 #include <vsstyle.h>
 #include <vssym32.h>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_handle.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 97 matching lines @@
 }
 
 RECT InsetRect(const RECT* rect, int size) {
   gfx::Rect result(*rect);
   result.Inset(size, size);
   return result.ToRECT();
 }
 
 }  // namespace
 
-namespace gfx {
+namespace ui {
 
 bool NativeThemeWin::IsThemingActive() const {
   if (is_theme_active_)
     return !!is_theme_active_();
   return false;
 }
 
 HRESULT NativeThemeWin::GetThemeColor(ThemeName theme,
                                       int part_id,
                                       int state_id,
@@ skipping 15 matching lines @@
                                                  int part_id,
                                                  int state_id,
                                                  int prop_id,
                                                  int default_sys_color) const {
   SkColor color;
   if (GetThemeColor(theme, part_id, state_id, prop_id, &color) != S_OK)
     color = skia::COLORREFToSkColor(GetSysColor(default_sys_color));
   return color;
 }
 
-Size NativeThemeWin::GetThemeBorderSize(ThemeName theme) const {
+gfx::Size NativeThemeWin::GetThemeBorderSize(ThemeName theme) const {
   // For simplicity use the wildcard state==0, part==0, since it works
   // for the cases we currently depend on.
   int border;
   if (GetThemeInt(theme, 0, 0, TMT_BORDERSIZE, &border) == S_OK)
-    return Size(border, border);
+    return gfx::Size(border, border);
   else
-    return Size(GetSystemMetrics(SM_CXEDGE), GetSystemMetrics(SM_CYEDGE));
+    return gfx::Size(GetSystemMetrics(SM_CXEDGE), GetSystemMetrics(SM_CYEDGE));
 }
 
 void NativeThemeWin::DisableTheming() const {
   if (!set_theme_properties_)
     return;
   set_theme_properties_(0);
 }
 
 void NativeThemeWin::CloseHandles() const {
   if (!close_theme_)
@@ skipping 95 matching lines @@
         size.cx = 13;
         size.cy = 13;
         break;
       default:
         size.cx = 0;
         size.cy = 0;
         break;
     }
   }
 
-  return Size(size.cx, size.cy);
+  return gfx::Size(size.cx, size.cy);
 }
 
 void NativeThemeWin::Paint(SkCanvas* canvas,
                            Part part,
                            State state,
                            const gfx::Rect& rect,
                            const ExtraParams& extra) const {
   if (!skia::SupportsPlatformPaint(canvas)) {
     // This block will only get hit with --enable-accelerated-drawing flag.
     PaintToNonPlatformCanvas(canvas, part, state, rect, extra);
@@ skipping 348 matching lines @@
   RECT rect_win = rect.ToRECT();
   if (handle && draw_theme_) {
     if (extra.pointing_right) {
       return draw_theme_(handle, hdc, MENU_POPUPSUBMENU, state_id, &rect_win,
                          NULL);
     } else {
       // There is no way to tell the uxtheme API to draw a left pointing arrow;
       // it doesn't have a flag equivalent to DFCS_MENUARROWRIGHT.  But they
       // are needed for RTL locales on Vista.  So use a memory DC and mirror
       // the region with GDI's StretchBlt.
-      Rect r(rect);
+      gfx::Rect r(rect);
       base::win::ScopedCreateDC mem_dc(CreateCompatibleDC(hdc));
       base::win::ScopedBitmap mem_bitmap(CreateCompatibleBitmap(hdc, r.width(),
                                                                 r.height()));
       base::win::ScopedSelectObject select_bitmap(mem_dc, mem_bitmap);
       // Copy and horizontally mirror the background from hdc into mem_dc. Use
       // a negative-width source rect, starting at the rightmost pixel.
       StretchBlt(mem_dc, 0, 0, r.width(), r.height(),
                  hdc, r.right()-1, r.y(), -r.width(), r.height(), SRCCOPY);
       // Draw the arrow.
       RECT theme_rect = {0, 0, r.width(), r.height()};
@@ skipping 315 matching lines @@
     Part part,
     State state,
     const gfx::Rect& rect,
     const ScrollbarThumbExtraParams& extra) const {
   HANDLE handle = GetThemeHandle(SCROLLBAR);
   RECT rect_win = rect.ToRECT();
   int part_id;
   int state_id;
 
   switch (part) {
-    case gfx::NativeTheme::kScrollbarHorizontalThumb:
+    case NativeTheme::kScrollbarHorizontalThumb:
       part_id = SBP_THUMBBTNHORZ;
       break;
-    case gfx::NativeTheme::kScrollbarVerticalThumb:
+    case NativeTheme::kScrollbarVerticalThumb:
       part_id = SBP_THUMBBTNVERT;
       break;
-    case gfx::NativeTheme::kScrollbarHorizontalGripper:
+    case NativeTheme::kScrollbarHorizontalGripper:
       part_id = SBP_GRIPPERHORZ;
       break;
-    case gfx::NativeTheme::kScrollbarVerticalGripper:
+    case NativeTheme::kScrollbarVerticalGripper:
       part_id = SBP_GRIPPERVERT;
       break;
     default:
       NOTREACHED() << "Invalid part: " << part;
       break;
   }
 
   switch (state) {
     case kDisabled:
       state_id = SCRBS_DISABLED;
@@ skipping 28 matching lines @@
     Part part,
     State state,
     const gfx::Rect& rect,
     const ScrollbarTrackExtraParams& extra) const {
   HANDLE handle = GetThemeHandle(SCROLLBAR);
   RECT rect_win = rect.ToRECT();
   int part_id;
   int state_id;
 
   switch (part) {
-    case gfx::NativeTheme::kScrollbarHorizontalTrack:
+    case NativeTheme::kScrollbarHorizontalTrack:
       part_id = extra.is_upper ? SBP_UPPERTRACKHORZ : SBP_LOWERTRACKHORZ;
       break;
-    case gfx::NativeTheme::kScrollbarVerticalTrack:
+    case NativeTheme::kScrollbarVerticalTrack:
       part_id = extra.is_upper ? SBP_UPPERTRACKVERT : SBP_LOWERTRACKVERT;
       break;
     default:
       NOTREACHED() << "Invalid part: " << part;
       break;
   }
 
   switch (state) {
     case kDisabled:
       state_id = SCRBS_DISABLED;
@@ skipping 630 matching lines @@
   RECT local_rect = { 0, 0, width, height };
   DrawFrameControl(bitmap_dc, &local_rect, type, state);
 
   // We're going to use BitBlt with a b&w mask. This results in using the dest
   // dc's text color for the black bits in the mask, and the dest dc's
   // background color for the white bits in the mask. DrawFrameControl draws the
   // check in black, and the background in white.
   int bg_color_key;
   int text_color_key;
   switch (control_state) {
-    case gfx::NativeTheme::kHovered:
+    case NativeTheme::kHovered:
       bg_color_key = COLOR_HIGHLIGHT;
       text_color_key = COLOR_HIGHLIGHTTEXT;
       break;
-    case gfx::NativeTheme::kNormal:
+    case NativeTheme::kNormal:
       bg_color_key = COLOR_MENU;
       text_color_key = COLOR_MENUTEXT;
       break;
-    case gfx::NativeTheme::kDisabled:
+    case NativeTheme::kDisabled:
       bg_color_key = is_selected ? COLOR_HIGHLIGHT : COLOR_MENU;
       text_color_key = COLOR_GRAYTEXT;
       break;
     default:
       NOTREACHED();
       bg_color_key = COLOR_MENU;
       text_color_key = COLOR_MENUTEXT;
       break;
   }
   COLORREF old_bg_color = SetBkColor(hdc, GetSysColor(bg_color_key));
@@ skipping 51 matching lines @@
   case SPIN:
     handle = open_theme_(NULL, L"Spin");
     break;
   default:
     NOTREACHED();
   }
   theme_handles_[theme_name] = handle;
   return handle;
 }
 
-}  // namespace gfx
+}  // namespace ui