18 files changed, 1028 insertions, 6 deletions

diff --git a/chrome/app/theme/theme_resources.grd b/chrome/app/theme/theme_resources.grd
index 85e5a60..a333eac 100644
--- a/chrome/app/theme/theme_resources.grd
+++ b/chrome/app/theme/theme_resources.grd
@@ -557,6 +557,18 @@
         <include name="IDR_USER_IMAGE_CAPTURE" file="snapshot_wide.png" type="BINDATA" />
         <include name="IDR_USER_IMAGE_RECYCLE" file="discard_wide.png" type="BINDATA" />
         <include name="IDR_VOLUMEBUBBLE_ICON" file="volume_icon.png" type="BINDATA" />
+        <include name="IDR_SCROLL_BACKGROUND" file="chromeos_scroll_background.png" type="BINDATA" />
+        <include name="IDR_SCROLL_BACKGROUND_BORDER_UP" file="chromeos_scroll_background_border_up.png" type="BINDATA" />
+        <include name="IDR_SCROLL_BACKGROUND_BORDER_DOWN" file="chromeos_scroll_background_border_down.png" type="BINDATA" />
+        <include name="IDR_SCROLL_ARROW_DOWN" file="chromeos_scroll_arrow_down.png" type="BINDATA" />
+        <include name="IDR_SCROLL_ARROW_DOWN_H" file="chromeos_scroll_arrow_down_h.png" type="BINDATA" />
+        <include name="IDR_SCROLL_ARROW_DOWN_P" file="chromeos_scroll_arrow_down_p.png" type="BINDATA" />
+        <include name="IDR_SCROLL_ARROW_UP" file="chromeos_scroll_arrow_up.png" type="BINDATA" />
+        <include name="IDR_SCROLL_ARROW_UP_H" file="chromeos_scroll_arrow_up_h.png" type="BINDATA" />
+        <include name="IDR_SCROLL_ARROW_UP_P" file="chromeos_scroll_arrow_up_p.png" type="BINDATA" />
+        <include name="IDR_SCROLL_THUMB" file="chromeos_scroll_thumb.png" type="BINDATA" />
+        <include name="IDR_SCROLL_THUMB_H" file="chromeos_scroll_thumb_h.png" type="BINDATA" />
+        <include name="IDR_SCROLL_THUMB_P" file="chromeos_scroll_thumb_p.png" type="BINDATA" />
       </if>
     </includes>
   </release>
diff --git a/chrome/browser/chromeos/native_theme_chromeos.cc b/chrome/browser/chromeos/native_theme_chromeos.cc
new file mode 100644
index 0000000..b0c4661
--- /dev/null
+++ b/chrome/browser/chromeos/native_theme_chromeos.cc
@@ -0,0 +1,256 @@
+// Copyright (c) 2010 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 "chrome/browser/chromeos/native_theme_chromeos.h"
+
+#include "app/resource_bundle.h"
+#include "base/logging.h"
+#include "gfx/insets.h"
+#include "gfx/rect.h"
+#include "gfx/size.h"
+#include "gfx/skbitmap_operations.h"
+#include "grit/theme_resources.h"
+#include "third_party/skia/include/core/SkShader.h"
+
+namespace {
+
+bool IntersectsClipRectInt(
+    skia::PlatformCanvas* canvas, int x, int y, int w, int h) {
+  SkRect clip;
+  return canvas->getClipBounds(&clip) &&
+      clip.intersect(SkIntToScalar(x), SkIntToScalar(y), SkIntToScalar(x + w),
+                     SkIntToScalar(y + h));
+}
+
+void DrawBitmapInt(
+    skia::PlatformCanvas* canvas, const SkBitmap& bitmap,
+    int src_x, int src_y, int src_w, int src_h,
+    int dest_x, int dest_y, int dest_w, int dest_h) {
+  DLOG_ASSERT(src_x + src_w < std::numeric_limits<int16_t>::max() &&
+              src_y + src_h < std::numeric_limits<int16_t>::max());
+  if (src_w <= 0 || src_h <= 0 || dest_w <= 0 || dest_h <= 0) {
+    NOTREACHED() << "Attempting to draw bitmap to/from an empty rect!";
+    return;
+  }
+
+  if (!IntersectsClipRectInt(canvas, dest_x, dest_y, dest_w, dest_h))
+    return;
+
+  SkRect dest_rect = { SkIntToScalar(dest_x),
+                       SkIntToScalar(dest_y),
+                       SkIntToScalar(dest_x + dest_w),
+                       SkIntToScalar(dest_y + dest_h) };
+
+  if (src_w == dest_w && src_h == dest_h) {
+    // Workaround for apparent bug in Skia that causes image to occasionally
+    // shift.
+    SkIRect src_rect = { src_x, src_y, src_x + src_w, src_y + src_h };
+    canvas->drawBitmapRect(bitmap, &src_rect, dest_rect);
+    return;
+  }
+
+  // Make a bitmap shader that contains the bitmap we want to draw. This is
+  // basically what SkCanvas.drawBitmap does internally, but it gives us
+  // more control over quality and will use the mipmap in the source image if
+  // it has one, whereas drawBitmap won't.
+  SkShader* shader = SkShader::CreateBitmapShader(bitmap,
+                                                  SkShader::kRepeat_TileMode,
+                                                  SkShader::kRepeat_TileMode);
+  SkMatrix shader_scale;
+  shader_scale.setScale(SkFloatToScalar(static_cast<float>(dest_w) / src_w),
+                        SkFloatToScalar(static_cast<float>(dest_h) / src_h));
+  shader_scale.preTranslate(SkIntToScalar(-src_x), SkIntToScalar(-src_y));
+  shader_scale.postTranslate(SkIntToScalar(dest_x), SkIntToScalar(dest_y));
+  shader->setLocalMatrix(shader_scale);
+
+  // The rect will be filled by the bitmap.
+  SkPaint p;
+  p.setFilterBitmap(true);
+  p.setShader(shader);
+  shader->unref();
+  canvas->drawRect(dest_rect, p);
+}
+
+}
+
+/* static */
+gfx::NativeThemeLinux* gfx::NativeThemeLinux::instance() {
+  // The global NativeThemeChromeos instance.
+  static NativeThemeChromeos s_native_theme;
+  return &s_native_theme;
+}
+
+NativeThemeChromeos::NativeThemeChromeos() {
+}
+
+NativeThemeChromeos::~NativeThemeChromeos() {
+}
+
+gfx::Size NativeThemeChromeos::GetSize(Part part) const {
+  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+  int scrollbar_width = rb.GetBitmapNamed(IDR_SCROLL_BACKGROUND)->width();
+  int width = 0, height = 0;
+  switch (part) {
+    case kScrollbarUpArrow:
+      width = scrollbar_width;
+      height = rb.GetBitmapNamed(IDR_SCROLL_ARROW_UP)->height();
+      break;
+    case kScrollbarDownArrow:
+      width = scrollbar_width;
+      height = rb.GetBitmapNamed(IDR_SCROLL_ARROW_DOWN)->height();
+      break;
+    case kScrollbarLeftArrow:
+      width = rb.GetBitmapNamed(IDR_SCROLL_ARROW_UP)->height();
+      height = scrollbar_width;
+      break;
+    case kScrollbarRightArrow:
+      width = rb.GetBitmapNamed(IDR_SCROLL_ARROW_DOWN)->height();
+      height = scrollbar_width;
+      break;
+    case kScrollbarHorizontalTrack:
+      width = 0;
+      height = scrollbar_width;
+      break;
+    case kScrollbarVerticalTrack:
+      width = scrollbar_width;
+      height = 0;
+      break;
+    case kScrollbarHorizontalThumb:
+    case kScrollbarVerticalThumb:
+      // allow thumb to be square but no shorter.
+      width = scrollbar_width;
+      height = scrollbar_width;
+      break;
+  }
+  return gfx::Size(width, height);
+}
+
+void NativeThemeChromeos::PaintTrack(skia::PlatformCanvas* canvas,
+    Part part, State state,
+    const ScrollbarTrackExtraParams& extra_params, const gfx::Rect& rect) {
+  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+  if (part == kScrollbarVerticalTrack) {
+    SkBitmap* background =
+        rb.GetBitmapNamed(IDR_SCROLL_BACKGROUND);
+    SkBitmap* border_up =
+        rb.GetBitmapNamed(IDR_SCROLL_BACKGROUND_BORDER_UP);
+    SkBitmap* border_down =
+        rb.GetBitmapNamed(IDR_SCROLL_BACKGROUND_BORDER_DOWN);
+    // Draw track background.
+    DrawBitmapInt(
+        canvas, *background,
+        0, 0, background->width(), 1,
+        rect.x(), rect.y(), rect.width(), rect.height());
+    // Draw up button lower border.
+    canvas->drawBitmap(*border_up, extra_params.track_x, extra_params.track_y);
+    // Draw down button upper border.
+    canvas->drawBitmap(
+        *border_down,
+        extra_params.track_x,
+        extra_params.track_y + extra_params.track_height - border_down->height()
+        );
+  } else {
+    SkBitmap* background =
+        GetHorizontalBitmapNamed(IDR_SCROLL_BACKGROUND);
+    SkBitmap* border_left =
+        GetHorizontalBitmapNamed(IDR_SCROLL_BACKGROUND_BORDER_UP);
+    SkBitmap* border_right =
+        GetHorizontalBitmapNamed(IDR_SCROLL_BACKGROUND_BORDER_DOWN);
+    // Draw track background.
+    DrawBitmapInt(
+        canvas, *background,
+        0, 0, 1, background->height(),
+        rect.x(), rect.y(), rect.width(), rect.height());
+    // Draw left button right border.
+    canvas->drawBitmap(*border_left,extra_params.track_x, extra_params.track_y);
+    // Draw right button left border.
+    canvas->drawBitmap(
+        *border_right,
+        extra_params.track_x + extra_params.track_width - border_right->width(),
+        extra_params.track_y);
+  }
+}
+
+void NativeThemeChromeos::PaintThumb(skia::PlatformCanvas* canvas,
+    Part part, State state, const gfx::Rect& rect) {
+  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+  int resource_id = IDR_SCROLL_THUMB;
+  if (state == kHover)
+    resource_id++;
+  else if (state == kPressed)
+    resource_id += 2;
+  if (part == kScrollbarVerticalThumb) {
+    SkBitmap* bitmap = rb.GetBitmapNamed(resource_id);
+    // Top
+    DrawBitmapInt(
+        canvas, *bitmap,
+        0, 1, bitmap->width(), 5,
+        rect.x(), rect.y(), rect.width(), 5);
+    // Middle
+    DrawBitmapInt(
+        canvas, *bitmap,
+        0, 7, bitmap->width(), 1,
+        rect.x(), rect.y() + 5, rect.width(), rect.height() - 10);
+    // Bottom
+    DrawBitmapInt(
+        canvas, *bitmap,
+        0, 8, bitmap->width(), 5,
+        rect.x(), rect.y() + rect.height() - 5, rect.width(), 5);
+  } else {
+    SkBitmap* bitmap = GetHorizontalBitmapNamed(resource_id);
+    // Left
+    DrawBitmapInt(
+        canvas, *bitmap,
+        1, 0, 5, bitmap->height(),
+        rect.x(), rect.y(), 5, rect.height());
+    // Middle
+    DrawBitmapInt(
+        canvas, *bitmap,
+        7, 0, 1, bitmap->height(),
+        rect.x() + 5, rect.y(), rect.width() - 10, rect.height());
+    // Right
+    DrawBitmapInt(
+        canvas, *bitmap,
+        8, 0, 5, bitmap->height(),
+        rect.x() + rect.width() - 5, rect.y(), 5, rect.height());
+  }
+}
+
+void NativeThemeChromeos::PaintArrowButton(skia::PlatformCanvas* canvas,
+    const gfx::Rect& rect, Part part, State state) {
+  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+  int resource_id =
+      (part == kScrollbarUpArrow || part == kScrollbarLeftArrow) ?
+          IDR_SCROLL_ARROW_UP : IDR_SCROLL_ARROW_DOWN;
+  if (state == kHover)
+    resource_id++;
+  else if (state == kPressed)
+    resource_id += 2;
+  SkBitmap* bitmap;
+  if (part == kScrollbarUpArrow || part == kScrollbarDownArrow)
+    bitmap = rb.GetBitmapNamed(resource_id);
+  else
+    bitmap = GetHorizontalBitmapNamed(resource_id);
+  canvas->drawBitmap(*bitmap, rect.x(), rect.y());
+}
+
+SkBitmap* NativeThemeChromeos::GetHorizontalBitmapNamed(int resource_id) {
+  SkImageMap::const_iterator found = horizontal_bitmaps_.find(resource_id);
+  if (found != horizontal_bitmaps_.end())
+    return found->second;
+
+  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
+  SkBitmap* vertical_bitmap = rb.GetBitmapNamed(resource_id);
+
+  if (vertical_bitmap) {
+    SkBitmap transposed_bitmap =
+        SkBitmapOperations::CreateTransposedBtmap(*vertical_bitmap);
+    SkBitmap* horizontal_bitmap = new SkBitmap(transposed_bitmap);
+
+    horizontal_bitmaps_[resource_id] = horizontal_bitmap;
+    return horizontal_bitmap;
+  }
+  return NULL;
+}
+
diff --git a/chrome/browser/chromeos/native_theme_chromeos.h b/chrome/browser/chromeos/native_theme_chromeos.h
new file mode 100644
index 0000000..d501f682e
--- /dev/null
+++ b/chrome/browser/chromeos/native_theme_chromeos.h
@@ -0,0 +1,39 @@
+// Copyright (c) 2010 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.
+
+#ifndef CHROME_BROWSER_CHROMEOS_NATIVE_THEME_CHROMEOS_H_
+#define CHROME_BROWSER_CHROMEOS_NATIVE_THEME_CHROMEOS_H_
+
+#include <map>
+#include "gfx/native_theme_linux.h"
+
+class SkBitmap;
+
+class NativeThemeChromeos : public gfx::NativeThemeLinux {
+ private:
+  friend class NativeThemeLinux;
+  NativeThemeChromeos();
+  virtual ~NativeThemeChromeos();
+
+  // Scrollbar painting overrides
+  virtual gfx::Size GetSize(Part part) const;
+  virtual void PaintTrack(skia::PlatformCanvas* canvas,
+      Part part, State state,
+      const ScrollbarTrackExtraParams& extra_params,
+      const gfx::Rect& rect);
+  virtual void PaintArrowButton(skia::PlatformCanvas* canvas,
+      const gfx::Rect& rect, Part direction, State state);
+  virtual void PaintThumb(skia::PlatformCanvas* canvas,
+      Part part, State state, const gfx::Rect& rect);
+  SkBitmap* GetHorizontalBitmapNamed(int resource_id);
+
+  // Cached images. The ResourceBundle caches all retrieved bitmaps and keeps
+  // ownership of the pointers.
+  typedef std::map<int, SkBitmap*> SkImageMap;
+  SkImageMap horizontal_bitmaps_;
+
+  DISALLOW_COPY_AND_ASSIGN(NativeThemeChromeos);
+};
+
+#endif  // CHROME_BROWSER_CHROMEOS_NATIVE_THEME_CHROMEOS_H_
diff --git a/chrome/chrome_browser.gypi b/chrome/chrome_browser.gypi
index bd284b7..d7c589d 100644
--- a/chrome/chrome_browser.gypi
+++ b/chrome/chrome_browser.gypi
@@ -639,6 +639,8 @@
         'browser/chromeos/low_battery_observer.h',
         'browser/chromeos/native_dialog_window.cc',
         'browser/chromeos/native_dialog_window.h',
+        'browser/chromeos/native_theme_chromeos.cc',
+        'browser/chromeos/native_theme_chromeos.h',
         'browser/chromeos/network_list.cc',
         'browser/chromeos/network_list.h',
         'browser/chromeos/network_state_notifier.cc',
diff --git a/chrome/renderer/render_view.cc b/chrome/renderer/render_view.cc
index 4d8a8b4..bfd4263 100644
--- a/chrome/renderer/render_view.cc
+++ b/chrome/renderer/render_view.cc
@@ -176,6 +176,7 @@
 //   * theming
 #include "gfx/native_theme_win.h"
 #elif defined(USE_X11)
+#include "gfx/native_theme_linux.h"
 #include "third_party/WebKit/WebKit/chromium/public/linux/WebRenderTheme.h"
 #elif defined(OS_MACOSX)
 #include "skia/ext/skia_utils_mac.h"
@@ -4425,6 +4426,10 @@ void RenderView::OnSetRendererPrefs(const RendererPreferences& renderer_prefs) {
   WebColorName name = WebKit::WebColorWebkitFocusRingColor;
   WebKit::setNamedColors(&name, &renderer_prefs.focus_ring_color, 1);
   WebKit::setCaretBlinkInterval(renderer_prefs.caret_blink_interval);
+  gfx::NativeThemeLinux::instance()->SetScrollbarColors(
+      renderer_prefs.thumb_inactive_color,
+      renderer_prefs.thumb_active_color,
+      renderer_prefs.track_color);
 
   if (webview()) {
     webview()->setScrollbarColors(
diff --git a/gfx/gfx.gyp b/gfx/gfx.gyp
index ba3d9e6..67cd8c1 100644
--- a/gfx/gfx.gyp
+++ b/gfx/gfx.gyp
@@ -82,6 +82,7 @@
         '../third_party/libpng/libpng.gyp:libpng',
         '../third_party/sqlite/sqlite.gyp:sqlite',
         '../third_party/zlib/zlib.gyp:zlib',
+        'gfx_resources',
       ],
       'sources': [
         'blit.cc',
@@ -167,6 +168,8 @@
             'gtk_native_view_id_manager.h',
             'gtk_util.cc',
             'gtk_util.h',
+            'native_theme_linux.cc',
+            'native_theme_linux.h',
             'native_widget_types_gtk.cc',
           ],
         }],
diff --git a/gfx/native_theme_linux.cc b/gfx/native_theme_linux.cc
new file mode 100644
index 0000000..d23cac4c
--- /dev/null
+++ b/gfx/native_theme_linux.cc
@@ -0,0 +1,399 @@
+// Copyright (c) 2010 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 "gfx/native_theme_linux.h"
+
+#include "base/logging.h"
+#include "gfx/size.h"
+#include "gfx/rect.h"
+
+namespace gfx {
+
+unsigned int NativeThemeLinux::button_length_ = 14;
+unsigned int NativeThemeLinux::scrollbar_width_ = 15;
+unsigned int NativeThemeLinux::thumb_inactive_color_ = 0xf0ebe5;
+unsigned int NativeThemeLinux::thumb_active_color_ = 0xfaf8f5;
+unsigned int NativeThemeLinux::track_color_ = 0xe3ddd8;
+
+#if !defined(OS_CHROMEOS)
+// Chromeos has a different look.
+// static
+NativeThemeLinux* NativeThemeLinux::instance() {
+  // The global NativeThemeLinux instance.
+  static NativeThemeLinux s_native_theme;
+  return &s_native_theme;
+}
+#endif
+
+NativeThemeLinux::NativeThemeLinux() {
+}
+
+NativeThemeLinux::~NativeThemeLinux() {
+}
+
+gfx::Size NativeThemeLinux::GetSize(Part part) const {
+  switch (part) {
+    case kScrollbarDownArrow:
+    case kScrollbarUpArrow:
+      return gfx::Size(scrollbar_width_, button_length_);
+    case kScrollbarLeftArrow:
+    case kScrollbarRightArrow:
+      return gfx::Size(button_length_, scrollbar_width_);
+    case kScrollbarHorizontalThumb:
+      // This matches Firefox on Linux.
+      return gfx::Size(2 * scrollbar_width_, scrollbar_width_);
+    case kScrollbarVerticalThumb:
+      // This matches Firefox on Linux.
+      return gfx::Size(scrollbar_width_, 2 * scrollbar_width_);
+      break;
+    case kScrollbarHorizontalTrack:
+      return gfx::Size(0, scrollbar_width_);
+    case kScrollbarVerticalTrack:
+      return gfx::Size(scrollbar_width_, 0);
+  }
+  return gfx::Size();
+}
+
+void NativeThemeLinux::PaintArrowButton(
+    skia::PlatformCanvas* canvas,
+    const gfx::Rect& rect, Part direction, State state) {
+  int widthMiddle, lengthMiddle;
+  SkPaint paint;
+  if (direction == kScrollbarUpArrow || direction == kScrollbarDownArrow) {
+    widthMiddle = rect.width() / 2 + 1;
+    lengthMiddle = rect.height() / 2 + 1;
+  } else {
+    lengthMiddle = rect.width() / 2 + 1;
+    widthMiddle = rect.height() / 2 + 1;
+  }
+
+  // Calculate button color.
+  SkScalar trackHSV[3];
+  SkColorToHSV(track_color_, trackHSV);
+  SkColor buttonColor = SaturateAndBrighten(trackHSV, 0, 0.2);
+  SkColor backgroundColor = buttonColor;
+  if (state == kPressed) {
+    SkScalar buttonHSV[3];
+    SkColorToHSV(buttonColor, buttonHSV);
+    buttonColor = SaturateAndBrighten(buttonHSV, 0, -0.1);
+  } else if (state == kHover) {
+    SkScalar buttonHSV[3];
+    SkColorToHSV(buttonColor, buttonHSV);
+    buttonColor = SaturateAndBrighten(buttonHSV, 0, 0.05);
+  }
+
+  SkIRect skrect;
+  skrect.set(rect.x(), rect.y(), rect.x() + rect.width(), rect.y()
+      + rect.height());
+  // Paint the background (the area visible behind the rounded corners).
+  paint.setColor(backgroundColor);
+  canvas->drawIRect(skrect, paint);
+
+  // Paint the button's outline and fill the middle
+  SkPath outline;
+  switch (direction) {
+    case kScrollbarUpArrow:
+      outline.moveTo(rect.x() + 0.5, rect.y() + rect.height() + 0.5);
+      outline.rLineTo(0, -(rect.height() - 2));
+      outline.rLineTo(2, -2);
+      outline.rLineTo(rect.width() - 5, 0);
+      outline.rLineTo(2, 2);
+      outline.rLineTo(0, rect.height() - 2);
+      break;
+    case kScrollbarDownArrow:
+      outline.moveTo(rect.x() + 0.5, rect.y() - 0.5);
+      outline.rLineTo(0, rect.height() - 2);
+      outline.rLineTo(2, 2);
+      outline.rLineTo(rect.width() - 5, 0);
+      outline.rLineTo(2, -2);
+      outline.rLineTo(0, -(rect.height() - 2));
+      break;
+    case kScrollbarRightArrow:
+      outline.moveTo(rect.x() - 0.5, rect.y() + 0.5);
+      outline.rLineTo(rect.width() - 2, 0);
+      outline.rLineTo(2, 2);
+      outline.rLineTo(0, rect.height() - 5);
+      outline.rLineTo(-2, 2);
+      outline.rLineTo(-(rect.width() - 2), 0);
+      break;
+    case kScrollbarLeftArrow:
+      outline.moveTo(rect.x() + rect.width() + 0.5, rect.y() + 0.5);
+      outline.rLineTo(-(rect.width() - 2), 0);
+      outline.rLineTo(-2, 2);
+      outline.rLineTo(0, rect.height() - 5);
+      outline.rLineTo(2, 2);
+      outline.rLineTo(rect.width() - 2, 0);
+      break;
+    default:
+      break;
+  }
+  outline.close();
+
+  paint.setStyle(SkPaint::kFill_Style);
+  paint.setColor(buttonColor);
+  canvas->drawPath(outline, paint);
+
+  paint.setAntiAlias(true);
+  paint.setStyle(SkPaint::kStroke_Style);
+  SkScalar thumbHSV[3];
+  SkColorToHSV(thumb_inactive_color_, thumbHSV);
+  paint.setColor(OutlineColor(trackHSV, thumbHSV));
+  canvas->drawPath(outline, paint);
+
+  // If the button is disabled or read-only, the arrow is drawn with the
+  // outline color.
+  if (state != kDisabled)
+    paint.setColor(SK_ColorBLACK);
+
+  paint.setAntiAlias(false);
+  paint.setStyle(SkPaint::kFill_Style);
+
+  SkPath path;
+  // The constants in this block of code are hand-tailored to produce good
+  // looking arrows without anti-aliasing.
+  switch (direction) {
+    case kScrollbarUpArrow:
+      path.moveTo(rect.x() + widthMiddle - 4, rect.y() + lengthMiddle + 2);
+      path.rLineTo(7, 0);
+      path.rLineTo(-4, -4);
+      break;
+    case kScrollbarDownArrow:
+      path.moveTo(rect.x() + widthMiddle - 4, rect.y() + lengthMiddle - 3);
+      path.rLineTo(7, 0);
+      path.rLineTo(-4, 4);
+      break;
+    case kScrollbarRightArrow:
+      path.moveTo(rect.x() + lengthMiddle - 3, rect.y() + widthMiddle - 4);
+      path.rLineTo(0, 7);
+      path.rLineTo(4, -4);
+      break;
+    case kScrollbarLeftArrow:
+      path.moveTo(rect.x() + lengthMiddle + 1, rect.y() + widthMiddle - 5);
+      path.rLineTo(0, 9);
+      path.rLineTo(-4, -4);
+      break;
+    default:
+      break;
+  }
+  path.close();
+
+  canvas->drawPath(path, paint);
+}
+
+void NativeThemeLinux::Paint(skia::PlatformCanvas* canvas,
+                             Part part,
+                             State state,
+                             const gfx::Rect& rect,
+                             const ExtraParams& extra) {
+  switch (part) {
+    case kScrollbarDownArrow:
+    case kScrollbarUpArrow:
+    case kScrollbarLeftArrow:
+    case kScrollbarRightArrow:
+      PaintArrowButton(canvas, rect, part, state);
+      break;
+    case kScrollbarHorizontalThumb:
+    case kScrollbarVerticalThumb:
+      PaintThumb(canvas, part, state, rect);
+      break;
+    case kScrollbarHorizontalTrack:
+    case kScrollbarVerticalTrack:
+      PaintTrack(canvas, part, state, extra.scrollbar_track, rect);
+      break;
+  }
+}
+
+void NativeThemeLinux::PaintTrack(skia::PlatformCanvas* canvas,
+                                  Part part,
+                                  State state,
+                                  const ScrollbarTrackExtraParams& extra_params,
+                                  const gfx::Rect& rect) {
+  SkPaint paint;
+  SkIRect skrect;
+
+  skrect.set(rect.x(), rect.y(), rect.right(), rect.bottom());
+  SkScalar track_hsv[3];
+  SkColorToHSV(track_color_, track_hsv);
+  paint.setColor(SaturateAndBrighten(track_hsv, 0, 0));
+  canvas->drawIRect(skrect, paint);
+
+  SkScalar thumb_hsv[3];
+  SkColorToHSV(thumb_inactive_color_, thumb_hsv);
+
+  paint.setColor(OutlineColor(track_hsv, thumb_hsv));
+  DrawBox(canvas, rect, paint);
+}
+
+void NativeThemeLinux::PaintThumb(skia::PlatformCanvas* canvas,
+                                  Part part,
+                                  State state,
+                                  const gfx::Rect& rect) {
+  const bool hovered = state == kHover;
+  const int midx = rect.x() + rect.width() / 2;
+  const int midy = rect.y() + rect.height() / 2;
+  const bool vertical = part == kScrollbarVerticalThumb;
+
+  SkScalar thumb[3];
+  SkColorToHSV(hovered ? thumb_active_color_ : thumb_inactive_color_, thumb);
+
+  SkPaint paint;
+  paint.setColor(SaturateAndBrighten(thumb, 0, 0.02));
+
+  SkIRect skrect;
+  if (vertical)
+    skrect.set(rect.x(), rect.y(), midx + 1, rect.y() + rect.height());
+  else
+    skrect.set(rect.x(), rect.y(), rect.x() + rect.width(), midy + 1);
+
+  canvas->drawIRect(skrect, paint);
+
+  paint.setColor(SaturateAndBrighten(thumb, 0, -0.02));
+
+  if (vertical) {
+    skrect.set(
+        midx + 1, rect.y(), rect.x() + rect.width(), rect.y() + rect.height());
+  } else {
+    skrect.set(
+        rect.x(), midy + 1, rect.x() + rect.width(), rect.y() + rect.height());
+  }
+
+  canvas->drawIRect(skrect, paint);
+
+  SkScalar track[3];
+  SkColorToHSV(track_color_, track);
+  paint.setColor(OutlineColor(track, thumb));
+  DrawBox(canvas, rect, paint);
+
+  if (rect.height() > 10 && rect.width() > 10) {
+    const int grippy_half_width = 2;
+    const int inter_grippy_offset = 3;
+    if (vertical) {
+      DrawHorizLine(canvas,
+                    midx - grippy_half_width,
+                    midx + grippy_half_width,
+                    midy - inter_grippy_offset,
+                    paint);
+      DrawHorizLine(canvas,
+                    midx - grippy_half_width,
+                    midx + grippy_half_width,
+                    midy,
+                    paint);
+      DrawHorizLine(canvas,
+                    midx - grippy_half_width,
+                    midx + grippy_half_width,
+                    midy + inter_grippy_offset,
+                    paint);
+    } else {
+      DrawVertLine(canvas,
+                   midx - inter_grippy_offset,
+                   midy - grippy_half_width,
+                   midy + grippy_half_width,
+                   paint);
+      DrawVertLine(canvas,
+                   midx,
+                   midy - grippy_half_width,
+                   midy + grippy_half_width,
+                   paint);
+      DrawVertLine(canvas,
+                   midx + inter_grippy_offset,
+                   midy - grippy_half_width,
+                   midy + grippy_half_width,
+                   paint);
+    }
+  }
+}
+
+void NativeThemeLinux::DrawVertLine(SkCanvas* canvas,
+                                    int x,
+                                    int y1,
+                                    int y2,
+                                    const SkPaint& paint) const {
+  SkIRect skrect;
+  skrect.set(x, y1, x + 1, y2 + 1);
+  canvas->drawIRect(skrect, paint);
+}
+
+void NativeThemeLinux::DrawHorizLine(SkCanvas* canvas,
+                                     int x1,
+                                     int x2,
+                                     int y,
+                                     const SkPaint& paint) const {
+  SkIRect skrect;
+  skrect.set(x1, y, x2 + 1, y + 1);
+  canvas->drawIRect(skrect, paint);
+}
+
+void NativeThemeLinux::DrawBox(SkCanvas* canvas,
+                               const gfx::Rect& rect,
+                               const SkPaint& paint) const {
+  const int right = rect.x() + rect.width() - 1;
+  const int bottom = rect.y() + rect.height() - 1;
+  DrawHorizLine(canvas, rect.x(), right, rect.y(), paint);
+  DrawVertLine(canvas, right, rect.y(), bottom, paint);
+  DrawHorizLine(canvas, rect.x(), right, bottom, paint);
+  DrawVertLine(canvas, rect.x(), rect.y(), bottom, paint);
+}
+
+SkScalar NativeThemeLinux::Clamp(SkScalar value,
+                                 SkScalar min,
+                                 SkScalar max) const {
+  return std::min(std::max(value, min), max);
+}
+
+SkColor NativeThemeLinux::SaturateAndBrighten(SkScalar* hsv,
+                                              SkScalar saturate_amount,
+                                              SkScalar brighten_amount) const {
+  SkScalar color[3];
+  color[0] = hsv[0];
+  color[1] = Clamp(hsv[1] + saturate_amount, 0.0, 1.0);
+  color[2] = Clamp(hsv[2] + brighten_amount, 0.0, 1.0);
+  return SkHSVToColor(color);
+}
+
+SkColor NativeThemeLinux::OutlineColor(SkScalar* hsv1, SkScalar* hsv2) const {
+  // GTK Theme engines have way too much control over the layout of
+  // the scrollbar. We might be able to more closely approximate its
+  // look-and-feel, if we sent whole images instead of just colors
+  // from the browser to the renderer. But even then, some themes
+  // would just break.
+  //
+  // So, instead, we don't even try to 100% replicate the look of
+  // the native scrollbar. We render our own version, but we make
+  // sure to pick colors that blend in nicely with the system GTK
+  // theme. In most cases, we can just sample a couple of pixels
+  // from the system scrollbar and use those colors to draw our
+  // scrollbar.
+  //
+  // This works fine for the track color and the overall thumb
+  // color. But it fails spectacularly for the outline color used
+  // around the thumb piece.  Not all themes have a clearly defined
+  // outline. For some of them it is partially transparent, and for
+  // others the thickness is very unpredictable.
+  //
+  // So, instead of trying to approximate the system theme, we
+  // instead try to compute a reasonable looking choice based on the
+  // known color of the track and the thumb piece. This is difficult
+  // when trying to deal both with high- and low-contrast themes,
+  // and both with positive and inverted themes.
+  //
+  // The following code has been tested to look OK with all of the
+  // default GTK themes.
+  SkScalar min_diff = Clamp((hsv1[1] + hsv2[1]) * 1.2, 0.2, 0.5);
+  SkScalar diff = Clamp(fabs(hsv1[2] - hsv2[2]) / 2, min_diff, 0.5);
+
+  if (hsv1[2] + hsv2[2] > 1.0)
+    diff = -diff;
+
+  return SaturateAndBrighten(hsv2, -0.2, diff);
+}
+
+void NativeThemeLinux::SetScrollbarColors(unsigned inactive_color,
+                                          unsigned active_color,
+                                          unsigned track_color) const {
+  thumb_inactive_color_ = inactive_color;
+  thumb_active_color_ = active_color;
+  track_color_ = track_color;
+}
+
+}  // namespace gfx
diff --git a/gfx/native_theme_linux.h b/gfx/native_theme_linux.h
new file mode 100644
index 0000000..62a84e9
--- /dev/null
+++ b/gfx/native_theme_linux.h
@@ -0,0 +1,125 @@
+// Copyright (c) 2010 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.
+
+#ifndef GFX_NATIVE_THEME_LINUX_H_
+#define GFX_NATIVE_THEME_LINUX_H_
+
+#include "base/basictypes.h"
+#include "skia/ext/platform_canvas.h"
+
+namespace skia {
+class PlatformCanvas;
+}
+
+namespace gfx {
+class Rect;
+class Size;
+
+// Linux theming API.
+class NativeThemeLinux {
+ public:
+  // Gets our singleton instance.
+  static NativeThemeLinux* instance();
+
+  // The part to be painted / sized.
+  enum Part {
+    kScrollbarDownArrow,
+    kScrollbarLeftArrow,
+    kScrollbarRightArrow,
+    kScrollbarUpArrow,
+    kScrollbarHorizontalThumb,
+    kScrollbarVerticalThumb,
+    kScrollbarHorizontalTrack,
+    kScrollbarVerticalTrack
+  };
+
+  // The state of the part.
+  enum State {
+    kDisabled,
+    kHover,
+    kNormal,
+    kPressed,
+  };
+
+  // Extra data needed to draw scrollbar track correctly.
+  struct ScrollbarTrackExtraParams {
+    int track_x;
+    int track_y;
+    int track_width;
+    int track_height;
+  };
+
+  union ExtraParams {
+    ScrollbarTrackExtraParams scrollbar_track;
+  };
+
+  // Return the size of the part.
+  virtual gfx::Size GetSize(Part part) const;
+  // Paint the part to the canvas.
+  virtual void Paint(skia::PlatformCanvas* canvas,
+                     Part part,
+                     State state,
+                     const gfx::Rect& rect,
+                     const ExtraParams& extra);
+  // Supports theme specific colors.
+  void SetScrollbarColors(unsigned inactive_color,
+                          unsigned active_color,
+                          unsigned track_color) const;
+
+ protected:
+  NativeThemeLinux();
+  virtual ~NativeThemeLinux();
+
+  // Draw the arrow.
+  virtual void PaintArrowButton(
+      skia::PlatformCanvas* gc,
+      const gfx::Rect& rect,
+      Part direction,
+      State state);
+  // Paint the track. Done before the thumb so that it can contain alpha.
+  virtual void PaintTrack(skia::PlatformCanvas* canvas,
+                  Part part,
+                  State state,
+                  const ScrollbarTrackExtraParams& extra_params,
+                  const gfx::Rect& rect);
+  // Draw the thumb over the track.
+  virtual void PaintThumb(skia::PlatformCanvas* canvas,
+                  Part part,
+                  State state,
+                  const gfx::Rect& rect);
+
+ private:
+  void DrawVertLine(SkCanvas* canvas,
+                    int x,
+                    int y1,
+                    int y2,
+                    const SkPaint& paint) const;
+  void DrawHorizLine(SkCanvas* canvas,
+                     int x1,
+                     int x2,
+                     int y,
+                     const SkPaint& paint) const;
+  void DrawBox(SkCanvas* canvas,
+               const gfx::Rect& rect,
+               const SkPaint& paint) const;
+  SkScalar Clamp(SkScalar value,
+                 SkScalar min,
+                 SkScalar max) const;
+  SkColor SaturateAndBrighten(SkScalar* hsv,
+                              SkScalar saturate_amount,
+                              SkScalar brighten_amount) const;
+  SkColor OutlineColor(SkScalar* hsv1, SkScalar* hsv2) const;
+
+  static unsigned int scrollbar_width_;
+  static unsigned int button_length_;
+  static unsigned int thumb_inactive_color_;
+  static unsigned int thumb_active_color_;
+  static unsigned int track_color_;
+
+  DISALLOW_COPY_AND_ASSIGN(NativeThemeLinux);
+};
+
+}  // namespace gfx
+
+#endif  // GFX_NATIVE_THEME_LINUX_H_
diff --git a/gfx/skbitmap_operations.cc b/gfx/skbitmap_operations.cc
index b8cec11..6899553 100644
--- a/gfx/skbitmap_operations.cc
+++ b/gfx/skbitmap_operations.cc
@@ -695,3 +695,27 @@ SkBitmap SkBitmapOperations::UnPreMultiply(const SkBitmap& bitmap) {
   opaque_bitmap.setIsOpaque(true);
   return opaque_bitmap;
 }
+
+// static
+SkBitmap SkBitmapOperations::CreateTransposedBtmap(const SkBitmap& image) {
+  DCHECK(image.config() == SkBitmap::kARGB_8888_Config);
+
+  SkAutoLockPixels lock_image(image);
+
+  SkBitmap transposed;
+  transposed.setConfig(
+      SkBitmap::kARGB_8888_Config, image.height(), image.width(), 0);
+  transposed.allocPixels();
+  transposed.eraseARGB(0, 0, 0, 0);
+
+  for (int y = 0; y < image.height(); ++y) {
+    uint32* image_row = image.getAddr32(0, y);
+    for (int x = 0; x < image.width(); ++x) {
+      uint32* dst = transposed.getAddr32(y, x);
+      *dst = image_row[x];
+    }
+  }
+
+  return transposed;
+}
+
diff --git a/gfx/skbitmap_operations.h b/gfx/skbitmap_operations.h
index eb56761..e64c1aa 100644
--- a/gfx/skbitmap_operations.h
+++ b/gfx/skbitmap_operations.h
@@ -89,6 +89,9 @@ class SkBitmapOperations {
   // doesn't expect premultiplied colors.
   static SkBitmap UnPreMultiply(const SkBitmap& bitmap);
 
+  // Transpose the pixels in |bitmap| by swapping x and y.
+  static SkBitmap CreateTransposedBtmap(const SkBitmap& bitmap);
+
  private:
   SkBitmapOperations();  // Class for scoping only.
 
diff --git a/gfx/skbitmap_operations_unittest.cc b/gfx/skbitmap_operations_unittest.cc
index 83b732a0..bcad287 100644
--- a/gfx/skbitmap_operations_unittest.cc
+++ b/gfx/skbitmap_operations_unittest.cc
@@ -492,3 +492,26 @@ TEST(SkBitmapOperationsTest, UnPreMultiply) {
   EXPECT_EQ(0xFF00CC88, *result.getAddr32(0, 1));
   EXPECT_EQ(0x00000000u, *result.getAddr32(1, 1));  // "Division by zero".
 }
+
+TEST(SkBitmapOperationsTest, CreateTransposedBtmap) {
+  SkBitmap input;
+  input.setConfig(SkBitmap::kARGB_8888_Config, 2, 3);
+  input.allocPixels();
+
+  for (int x = 0; x < input.width(); ++x) {
+    for (int y = 0; y < input.height(); ++y) {
+      *input.getAddr32(x, y) = x * input.width() + y;
+    }
+  }
+
+  SkBitmap result = SkBitmapOperations::CreateTransposedBtmap(input);
+  EXPECT_EQ(3, result.width());
+  EXPECT_EQ(2, result.height());
+
+  SkAutoLockPixels lock(result);
+  for (int x = 0; x < input.width(); ++x) {
+    for (int y = 0; y < input.height(); ++y) {
+      EXPECT_EQ(*input.getAddr32(x, y), *result.getAddr32(y, x));
+    }
+  }
+}
diff --git a/webkit/glue/webkit_glue.gypi b/webkit/glue/webkit_glue.gypi
index 50dda7a..68336aa 100644
--- a/webkit/glue/webkit_glue.gypi
+++ b/webkit/glue/webkit_glue.gypi
@@ -381,6 +381,7 @@
         'websocketstreamhandle_delegate.h',
         'websocketstreamhandle_impl.cc',
         'websocketstreamhandle_impl.h',
+        'webthemeengine_impl_linux.cc',
         'webthemeengine_impl_win.cc',
         'weburlloader_impl.cc',
         'weburlloader_impl.h',
diff --git a/webkit/glue/webkitclient_impl.cc b/webkit/glue/webkitclient_impl.cc
index c65d176..e9b05f1 100644
--- a/webkit/glue/webkitclient_impl.cc
+++ b/webkit/glue/webkitclient_impl.cc
@@ -171,7 +171,7 @@ WebKitClientImpl::~WebKitClientImpl() {
 }
 
 WebThemeEngine* WebKitClientImpl::themeEngine() {
-#if defined(OS_WIN)
+#if defined(OS_WIN) || defined(OS_LINUX)
   return &theme_engine_;
 #else
   return NULL;
diff --git a/webkit/glue/webkitclient_impl.h b/webkit/glue/webkitclient_impl.h
index 607677f..68d0eaf 100644
--- a/webkit/glue/webkitclient_impl.h
+++ b/webkit/glue/webkitclient_impl.h
@@ -10,8 +10,11 @@
 #include "third_party/WebKit/WebKit/chromium/public/WebKitClient.h"
 #if defined(OS_WIN)
 #include "webkit/glue/webthemeengine_impl_win.h"
+#elif defined(OS_LINUX)
+#include "webkit/glue/webthemeengine_impl_linux.h"
 #endif
 
+
 class MessageLoop;
 
 namespace webkit_glue {
@@ -71,7 +74,7 @@ class WebKitClientImpl : public WebKit::WebKitClient {
   double shared_timer_fire_time_;
   int shared_timer_suspended_;  // counter
 
-#if defined(OS_WIN)
+#if defined(OS_WIN) || defined(OS_LINUX)
   WebThemeEngineImpl theme_engine_;
 #endif
 };
diff --git a/webkit/glue/webthemeengine_impl_linux.cc b/webkit/glue/webthemeengine_impl_linux.cc
new file mode 100644
index 0000000..d5cc9b4
--- /dev/null
+++ b/webkit/glue/webthemeengine_impl_linux.cc
@@ -0,0 +1,100 @@
+// Copyright (c) 2010 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 "webkit/glue/webthemeengine_impl_linux.h"
+
+#include "gfx/native_theme_linux.h"
+#include "skia/ext/platform_canvas.h"
+#include "third_party/WebKit/WebKit/chromium/public/WebRect.h"
+#include "third_party/WebKit/WebKit/chromium/public/WebSize.h"
+
+using WebKit::WebCanvas;
+using WebKit::WebColor;
+using WebKit::WebRect;
+
+namespace webkit_glue {
+
+static gfx::Rect WebRectToRect(const WebRect& rect) {
+  return gfx::Rect(rect.x, rect.y, rect.width, rect.height);
+}
+
+static gfx::NativeThemeLinux::Part NativeThemePart(
+    WebKit::WebThemeEngine::Part part) {
+  switch (part) {
+    case WebKit::WebThemeEngine::PartScrollbarDownArrow:
+      return gfx::NativeThemeLinux::kScrollbarDownArrow;
+    case WebKit::WebThemeEngine::PartScrollbarLeftArrow:
+      return gfx::NativeThemeLinux::kScrollbarLeftArrow;
+    case WebKit::WebThemeEngine::PartScrollbarRightArrow:
+      return gfx::NativeThemeLinux::kScrollbarRightArrow;
+    case WebKit::WebThemeEngine::PartScrollbarUpArrow:
+      return gfx::NativeThemeLinux::kScrollbarUpArrow;
+    case WebKit::WebThemeEngine::PartScrollbarHorizontalThumb:
+      return gfx::NativeThemeLinux::kScrollbarHorizontalThumb;
+    case WebKit::WebThemeEngine::PartScrollbarVerticalThumb:
+      return gfx::NativeThemeLinux::kScrollbarVerticalThumb;
+    case WebKit::WebThemeEngine::PartScrollbarHoriztonalTrack:
+      return gfx::NativeThemeLinux::kScrollbarHorizontalTrack;
+    case WebKit::WebThemeEngine::PartScrollbarVerticalTrack:
+      return gfx::NativeThemeLinux::kScrollbarVerticalTrack;
+    default:
+      return gfx::NativeThemeLinux::kScrollbarDownArrow;
+  }
+}
+
+static gfx::NativeThemeLinux::State NativeThemeState(
+    WebKit::WebThemeEngine::State state) {
+  switch (state) {
+    case WebKit::WebThemeEngine::StateDisabled:
+      return gfx::NativeThemeLinux::kDisabled;
+    case WebKit::WebThemeEngine::StateHover:
+      return gfx::NativeThemeLinux::kHover;
+    case WebKit::WebThemeEngine::StateNormal:
+      return gfx::NativeThemeLinux::kNormal;
+    case WebKit::WebThemeEngine::StatePressed:
+      return gfx::NativeThemeLinux::kPressed;
+    default:
+      return gfx::NativeThemeLinux::kDisabled;
+  }
+}
+
+static void GetNativeThemeExtraParams(
+    WebKit::WebThemeEngine::Part part,
+    WebKit::WebThemeEngine::State state,
+    const WebKit::WebThemeEngine::ExtraParams* extra_params,
+    gfx::NativeThemeLinux::ExtraParams* native_theme_extra_params) {
+  if (part == WebKit::WebThemeEngine::PartScrollbarHoriztonalTrack ||
+      part == WebKit::WebThemeEngine::PartScrollbarVerticalTrack) {
+    native_theme_extra_params->scrollbar_track.track_x =
+        extra_params->scrollbarTrack.trackX;
+    native_theme_extra_params->scrollbar_track.track_y =
+        extra_params->scrollbarTrack.trackY;
+    native_theme_extra_params->scrollbar_track.track_width =
+        extra_params->scrollbarTrack.trackWidth;
+    native_theme_extra_params->scrollbar_track.track_height =
+        extra_params->scrollbarTrack.trackHeight;
+  }
+}
+
+WebKit::WebSize WebThemeEngineImpl::getSize(WebKit::WebThemeEngine::Part part) {
+  return gfx::NativeThemeLinux::instance()->GetSize(NativeThemePart(part));
+}
+
+void WebThemeEngineImpl::paint(
+    WebKit::WebCanvas* canvas,
+    WebKit::WebThemeEngine::Part part,
+    WebKit::WebThemeEngine::State state,
+    const WebKit::WebRect& rect,
+    const WebKit::WebThemeEngine::ExtraParams* extra_params) {
+  gfx::NativeThemeLinux::ExtraParams native_theme_extra_params;
+  GetNativeThemeExtraParams(
+      part, state, extra_params, &native_theme_extra_params);
+  gfx::NativeThemeLinux::instance()->Paint(
+      canvas,
+      NativeThemePart(part),
+      NativeThemeState(state),
+      WebRectToRect(rect),
+      native_theme_extra_params);
+}
+}  // namespace webkit_glue
diff --git a/webkit/glue/webthemeengine_impl_linux.h b/webkit/glue/webthemeengine_impl_linux.h
new file mode 100644
index 0000000..265b80c
--- /dev/null
+++ b/webkit/glue/webthemeengine_impl_linux.h
@@ -0,0 +1,26 @@
+// Copyright (c) 2010 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.
+
+#ifndef WEBTHEMEENGINE_IMPL_LINUX_H_
+#define WEBTHEMEENGINE_IMPL_LINUX_H_
+
+#include "third_party/WebKit/WebKit/chromium/public/linux/WebThemeEngine.h"
+
+namespace webkit_glue {
+
+class WebThemeEngineImpl : public WebKit::WebThemeEngine {
+ public:
+  // WebThemeEngine methods:
+  virtual WebKit::WebSize getSize(WebKit::WebThemeEngine::Part);
+  virtual void paint(
+      WebKit::WebCanvas*,
+      WebKit::WebThemeEngine::Part,
+      WebKit::WebThemeEngine::State,
+      const WebKit::WebRect&,
+      const WebKit::WebThemeEngine::ExtraParams*);
+};
+
+}  // namespace webkit_glue
+
+#endif  // WEBTHEMEENGINE_IMPL_LINUX_H_
diff --git a/webkit/glue/webthemeengine_impl_win.h b/webkit/glue/webthemeengine_impl_win.h
index 533ea19..6e749c4 100644
--- a/webkit/glue/webthemeengine_impl_win.h
+++ b/webkit/glue/webthemeengine_impl_win.h
@@ -5,7 +5,7 @@
 #ifndef WEBTHEMEENGINE_IMPL_WIN_H_
 #define WEBTHEMEENGINE_IMPL_WIN_H_
 
-#include "third_party/WebKit/WebKit/chromium/public/WebThemeEngine.h"
+#include "third_party/WebKit/WebKit/chromium/public/win/WebThemeEngine.h"
 
 namespace webkit_glue {
 
diff --git a/webkit/support/test_webkit_client.cc b/webkit/support/test_webkit_client.cc
index 8382fd0..2bc1494 100644
--- a/webkit/support/test_webkit_client.cc
+++ b/webkit/support/test_webkit_client.cc
@@ -28,7 +28,6 @@
 #include "third_party/WebKit/WebKit/chromium/public/WebStorageEventDispatcher.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebStorageNamespace.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebString.h"
-#include "third_party/WebKit/WebKit/chromium/public/WebThemeEngine.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebURL.h"
 #include "webkit/appcache/web_application_cache_host_impl.h"
 #include "webkit/database/vfs_backend.h"
@@ -51,9 +50,11 @@
 #include "v8/include/v8.h"
 
 #if defined(OS_WIN)
+#include "third_party/WebKit/WebKit/chromium/public/win/WebThemeEngine.h"
 #include "webkit/tools/test_shell/test_shell_webthemeengine.h"
-#endif
-#if defined(OS_MACOSX)
+#elif defined(OS_LINUX)
+#include "third_party/WebKit/WebKit/chromium/public/linux/WebThemeEngine.h"
+#elif defined(OS_MACOSX)
 #include "base/mac_util.h"
 #endif